@openqa/cli 1.3.4 → 2.1.0

package/dist/cli/routes.js

@@ -0,0 +1,895 @@
+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 });
+};
+
+// 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";
+  }
+});
+
+// agent/coverage/index.ts
+var coverage_exports = {};
+__export(coverage_exports, {
+  CoverageTracker: () => CoverageTracker
+});
+var CoverageTracker;
+var init_coverage = __esm({
+  "agent/coverage/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    CoverageTracker = class {
+      routes = /* @__PURE__ */ new Map();
+      /**
+       * Register a known route (from code analysis or sitemap)
+       */
+      registerRoute(method, url) {
+        const key = `${method.toUpperCase()} ${url}`;
+        if (!this.routes.has(key)) {
+          this.routes.set(key, { url, method: method.toUpperCase(), tested: false, testCount: 0 });
+        }
+      }
+      /**
+       * Record that a route was exercised during a test session
+       */
+      recordTest(method, url) {
+        const key = `${method.toUpperCase()} ${url}`;
+        const existing = this.routes.get(key);
+        if (existing) {
+          existing.tested = true;
+          existing.lastTestedAt = (/* @__PURE__ */ new Date()).toISOString();
+          existing.testCount++;
+        } else {
+          this.routes.set(key, {
+            url,
+            method: method.toUpperCase(),
+            tested: true,
+            lastTestedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            testCount: 1
+          });
+        }
+      }
+      /**
+       * Build a coverage report
+       */
+      getReport() {
+        const entries = Array.from(this.routes.values());
+        const tested = entries.filter((e) => e.tested).length;
+        const total = entries.length;
+        return {
+          total,
+          tested,
+          untested: total - tested,
+          coveragePercent: total === 0 ? 0 : Math.round(tested / total * 100),
+          entries: entries.sort((a, b) => a.tested === b.tested ? 0 : a.tested ? 1 : -1)
+        };
+      }
+      /**
+       * Populate routes from an OpenAPI-style spec or action history
+       */
+      async loadFromDatabase(db, sessionId) {
+        const actions = await db.getSessionActions(sessionId);
+        for (const action of actions) {
+          if (action.type === "navigate" || action.type === "api_call" || action.type === "request") {
+            const urlMatch = (action.input || action.description).match(/(GET|POST|PUT|DELETE|PATCH|HEAD)\s+(https?:\/\/[^\s]+|\/[^\s]*)/i);
+            if (urlMatch) {
+              this.recordTest(urlMatch[1], urlMatch[2]);
+            } else {
+              const simpleUrl = (action.input || "").match(/https?:\/\/[^\s]+/);
+              if (simpleUrl) {
+                this.recordTest("GET", simpleUrl[0]);
+              }
+            }
+          }
+        }
+      }
+      reset() {
+        this.routes.clear();
+      }
+    };
+  }
+});
+
+// cli/routes.ts
+init_esm_shims();
+import { Router } from "express";
+import { z } from "zod";
+
+// agent/export/index.ts
+init_esm_shims();
+var ExportService = class {
+  constructor(db) {
+    this.db = db;
+  }
+  async exportSession(sessionId, format) {
+    const session = await this.db.getSession(sessionId);
+    if (!session) {
+      throw new Error(`Session ${sessionId} not found`);
+    }
+    const actions = await this.db.getSessionActions(sessionId);
+    const allBugs = await this.db.getAllBugs();
+    const bugs = allBugs.filter((b) => b.session_id === sessionId);
+    const data = { session, actions, bugs };
+    switch (format) {
+      case "json":
+        return {
+          content: JSON.stringify(data, null, 2),
+          contentType: "application/json",
+          filename: `openqa-session-${sessionId}.json`
+        };
+      case "csv":
+        return {
+          content: this.toCSV(data),
+          contentType: "text/csv",
+          filename: `openqa-session-${sessionId}.csv`
+        };
+      case "html":
+        return {
+          content: this.toHTML(data),
+          contentType: "text/html",
+          filename: `openqa-session-${sessionId}.html`
+        };
+    }
+  }
+  toCSV(data) {
+    const lines = [];
+    lines.push("# Session Summary");
+    lines.push("id,started_at,ended_at,status,total_actions,bugs_found");
+    lines.push([
+      data.session.id,
+      data.session.started_at,
+      data.session.ended_at || "",
+      data.session.status,
+      data.session.total_actions,
+      data.session.bugs_found
+    ].join(","));
+    lines.push("");
+    lines.push("# Actions");
+    lines.push("id,timestamp,type,description");
+    for (const a of data.actions) {
+      lines.push([
+        a.id,
+        a.timestamp,
+        this.csvEscape(a.type),
+        this.csvEscape(a.description)
+      ].join(","));
+    }
+    lines.push("");
+    lines.push("# Bugs");
+    lines.push("id,title,severity,status,created_at");
+    for (const b of data.bugs) {
+      lines.push([
+        b.id,
+        this.csvEscape(b.title),
+        b.severity,
+        b.status,
+        b.created_at
+      ].join(","));
+    }
+    return lines.join("\n");
+  }
+  csvEscape(value) {
+    if (value.includes(",") || value.includes('"') || value.includes("\n")) {
+      return `"${value.replace(/"/g, '""')}"`;
+    }
+    return value;
+  }
+  toHTML(data) {
+    const severityColor = {
+      critical: "#dc2626",
+      high: "#ea580c",
+      medium: "#ca8a04",
+      low: "#16a34a"
+    };
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>OpenQA Report \u2014 Session ${data.session.id}</title>
+  <style>
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+    body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif; max-width: 960px; margin: 0 auto; padding: 2rem; color: #1a1a2e; }
+    h1 { font-size: 1.5rem; margin-bottom: 0.5rem; }
+    h2 { font-size: 1.2rem; margin: 2rem 0 0.5rem; border-bottom: 2px solid #e2e8f0; padding-bottom: 0.25rem; }
+    .meta { color: #64748b; font-size: 0.9rem; margin-bottom: 1.5rem; }
+    .stats { display: flex; gap: 1.5rem; margin-bottom: 1.5rem; }
+    .stat { background: #f8fafc; border-radius: 8px; padding: 1rem; flex: 1; text-align: center; }
+    .stat-value { font-size: 1.5rem; font-weight: 700; }
+    .stat-label { color: #64748b; font-size: 0.8rem; }
+    table { width: 100%; border-collapse: collapse; margin-top: 0.5rem; }
+    th, td { text-align: left; padding: 0.5rem; border-bottom: 1px solid #e2e8f0; font-size: 0.85rem; }
+    th { background: #f8fafc; font-weight: 600; }
+    .badge { display: inline-block; padding: 2px 8px; border-radius: 4px; font-size: 0.75rem; color: white; }
+    .footer { margin-top: 3rem; color: #94a3b8; font-size: 0.8rem; text-align: center; }
+  </style>
+</head>
+<body>
+  <h1>OpenQA Session Report</h1>
+  <p class="meta">${data.session.id} &mdash; ${data.session.started_at}${data.session.ended_at ? ` to ${data.session.ended_at}` : " (in progress)"}</p>
+
+  <div class="stats">
+    <div class="stat"><div class="stat-value">${data.session.total_actions}</div><div class="stat-label">Actions</div></div>
+    <div class="stat"><div class="stat-value">${data.bugs.length}</div><div class="stat-label">Bugs Found</div></div>
+    <div class="stat"><div class="stat-value">${data.session.status}</div><div class="stat-label">Status</div></div>
+    <div class="stat"><div class="stat-value">${data.session.total_actions > 0 ? Math.round((data.session.total_actions - data.session.bugs_found) / data.session.total_actions * 100) : 0}%</div><div class="stat-label">Success Rate</div></div>
+  </div>
+
+  ${data.bugs.length > 0 ? `
+  <h2>Bugs (${data.bugs.length})</h2>
+  <table>
+    <thead><tr><th>Title</th><th>Severity</th><th>Status</th><th>Date</th></tr></thead>
+    <tbody>
+      ${data.bugs.map((b) => `<tr>
+        <td>${this.htmlEscape(b.title)}</td>
+        <td><span class="badge" style="background:${severityColor[b.severity] || "#64748b"}">${b.severity}</span></td>
+        <td>${b.status}</td>
+        <td>${b.created_at}</td>
+      </tr>`).join("\n      ")}
+    </tbody>
+  </table>` : ""}
+
+  ${data.actions.length > 0 ? `
+  <h2>Actions (${data.actions.length})</h2>
+  <table>
+    <thead><tr><th>Type</th><th>Description</th><th>Timestamp</th></tr></thead>
+    <tbody>
+      ${data.actions.slice(0, 100).map((a) => `<tr>
+        <td>${this.htmlEscape(a.type)}</td>
+        <td>${this.htmlEscape(a.description)}</td>
+        <td>${a.timestamp}</td>
+      </tr>`).join("\n      ")}
+    </tbody>
+  </table>
+  ${data.actions.length > 100 ? `<p class="meta">&hellip; and ${data.actions.length - 100} more actions</p>` : ""}` : ""}
+
+  <p class="footer">Generated by OpenQA on ${(/* @__PURE__ */ new Date()).toISOString()}</p>
+</body>
+</html>`;
+  }
+  htmlEscape(str) {
+    return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+  }
+};
+
+// agent/openapi/spec.ts
+init_esm_shims();
+function getOpenAPISpec() {
+  return {
+    openapi: "3.0.3",
+    info: {
+      title: "OpenQA API",
+      description: "Autonomous QA testing agent \u2014 REST API",
+      version: "1.3.4",
+      contact: { url: "https://openqa.orkajs.com" },
+      license: { name: "MIT" }
+    },
+    servers: [{ url: "/api", description: "OpenQA server" }],
+    tags: [
+      { name: "health", description: "Health & status" },
+      { name: "sessions", description: "Test sessions" },
+      { name: "bugs", description: "Bug reports" },
+      { name: "kanban", description: "Kanban board" },
+      { name: "config", description: "Configuration" },
+      { name: "agent", description: "Agent control" },
+      { name: "project", description: "Project runner" },
+      { name: "export", description: "Result export" },
+      { name: "coverage", description: "Test coverage" },
+      { name: "storage", description: "Storage management" }
+    ],
+    paths: {
+      "/health": {
+        get: {
+          tags: ["health"],
+          summary: "Health check",
+          responses: {
+            "200": {
+              description: "Service is healthy",
+              content: { "application/json": { schema: { $ref: "#/components/schemas/Health" } } }
+            }
+          }
+        }
+      },
+      "/status": {
+        get: {
+          tags: ["health"],
+          summary: "Agent status",
+          responses: {
+            "200": {
+              description: "Agent running state",
+              content: { "application/json": { schema: { $ref: "#/components/schemas/Status" } } }
+            }
+          }
+        }
+      },
+      "/sessions": {
+        get: {
+          tags: ["sessions"],
+          summary: "List recent sessions",
+          parameters: [{ name: "limit", in: "query", schema: { type: "integer", default: 10 } }],
+          responses: {
+            "200": {
+              description: "Array of sessions",
+              content: { "application/json": { schema: { type: "array", items: { $ref: "#/components/schemas/Session" } } } }
+            }
+          }
+        }
+      },
+      "/sessions/{id}/actions": {
+        get: {
+          tags: ["sessions"],
+          summary: "Get actions for a session",
+          parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }],
+          responses: {
+            "200": {
+              description: "Array of actions",
+              content: { "application/json": { schema: { type: "array", items: { $ref: "#/components/schemas/Action" } } } }
+            }
+          }
+        }
+      },
+      "/bugs": {
+        get: {
+          tags: ["bugs"],
+          summary: "List bugs",
+          parameters: [{ name: "status", in: "query", schema: { type: "string", enum: ["open", "in-progress", "resolved", "closed"] } }],
+          responses: {
+            "200": {
+              description: "Array of bugs",
+              content: { "application/json": { schema: { type: "array", items: { $ref: "#/components/schemas/Bug" } } } }
+            }
+          }
+        }
+      },
+      "/kanban": {
+        get: {
+          tags: ["kanban"],
+          summary: "List all kanban tickets",
+          responses: {
+            "200": {
+              description: "Array of tickets",
+              content: { "application/json": { schema: { type: "array", items: { $ref: "#/components/schemas/KanbanTicket" } } } }
+            }
+          }
+        },
+        post: {
+          tags: ["kanban"],
+          summary: "Create a kanban ticket",
+          requestBody: {
+            required: true,
+            content: { "application/json": { schema: { $ref: "#/components/schemas/KanbanTicketInput" } } }
+          },
+          responses: {
+            "200": { description: "Created ticket", content: { "application/json": { schema: { $ref: "#/components/schemas/KanbanTicket" } } } }
+          }
+        }
+      },
+      "/kanban/{id}": {
+        put: {
+          tags: ["kanban"],
+          summary: "Update a kanban ticket",
+          parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }],
+          requestBody: { required: true, content: { "application/json": { schema: { $ref: "#/components/schemas/KanbanTicketInput" } } } },
+          responses: { "200": { description: "Success", content: { "application/json": { schema: { $ref: "#/components/schemas/SuccessResponse" } } } } }
+        },
+        delete: {
+          tags: ["kanban"],
+          summary: "Delete a kanban ticket",
+          parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }],
+          responses: { "200": { description: "Success", content: { "application/json": { schema: { $ref: "#/components/schemas/SuccessResponse" } } } } }
+        }
+      },
+      "/config": {
+        get: {
+          tags: ["config"],
+          summary: "Get current configuration",
+          responses: { "200": { description: "Configuration object" } }
+        },
+        post: {
+          tags: ["config"],
+          summary: "Update configuration",
+          requestBody: { required: true, content: { "application/json": { schema: { type: "object" } } } },
+          responses: { "200": { description: "Success", content: { "application/json": { schema: { $ref: "#/components/schemas/SuccessResponse" } } } } }
+        }
+      },
+      "/agent/start": {
+        post: {
+          tags: ["agent"],
+          summary: "Start autonomous agent session",
+          responses: { "200": { description: "Started", content: { "application/json": { schema: { $ref: "#/components/schemas/SuccessResponse" } } } } }
+        }
+      },
+      "/agent/stop": {
+        post: {
+          tags: ["agent"],
+          summary: "Stop the running agent",
+          responses: { "200": { description: "Stopped", content: { "application/json": { schema: { $ref: "#/components/schemas/SuccessResponse" } } } } }
+        }
+      },
+      "/project/setup": {
+        post: {
+          tags: ["project"],
+          summary: "Setup project \u2014 detect, install deps, optionally start dev server",
+          requestBody: {
+            required: true,
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  required: ["repoPath"],
+                  properties: {
+                    repoPath: { type: "string", description: "Absolute path to the project" },
+                    startServer: { type: "boolean", description: "Start dev server after install" }
+                  }
+                }
+              }
+            }
+          },
+          responses: { "200": { description: "Project status", content: { "application/json": { schema: { $ref: "#/components/schemas/ProjectStatus" } } } } }
+        }
+      },
+      "/project/status": {
+        get: {
+          tags: ["project"],
+          summary: "Get project runner status",
+          responses: { "200": { description: "Status", content: { "application/json": { schema: { $ref: "#/components/schemas/ProjectStatus" } } } } }
+        }
+      },
+      "/project/test": {
+        post: {
+          tags: ["project"],
+          summary: "Run existing project tests",
+          requestBody: {
+            required: true,
+            content: { "application/json": { schema: { type: "object", required: ["repoPath"], properties: { repoPath: { type: "string" } } } } }
+          },
+          responses: { "200": { description: "Test results", content: { "application/json": { schema: { $ref: "#/components/schemas/TestRunResult" } } } } }
+        }
+      },
+      "/export/{sessionId}": {
+        get: {
+          tags: ["export"],
+          summary: "Export session results",
+          parameters: [
+            { name: "sessionId", in: "path", required: true, schema: { type: "string" } },
+            { name: "format", in: "query", schema: { type: "string", enum: ["json", "csv", "html"], default: "json" } }
+          ],
+          responses: {
+            "200": { description: "File download (json / csv / html)" },
+            "404": { description: "Session not found" }
+          }
+        }
+      },
+      "/coverage/{sessionId}": {
+        get: {
+          tags: ["coverage"],
+          summary: "Get coverage report for a session",
+          parameters: [{ name: "sessionId", in: "path", required: true, schema: { type: "string" } }],
+          responses: { "200": { description: "Coverage report", content: { "application/json": { schema: { $ref: "#/components/schemas/CoverageReport" } } } } }
+        }
+      },
+      "/storage": {
+        get: {
+          tags: ["storage"],
+          summary: "Get storage statistics",
+          responses: { "200": { description: "Storage stats" } }
+        }
+      },
+      "/cleanup": {
+        post: {
+          tags: ["storage"],
+          summary: "Prune old sessions",
+          parameters: [{ name: "maxAgeDays", in: "query", schema: { type: "integer", default: 30 } }],
+          responses: { "200": { description: "Cleanup result" } }
+        }
+      }
+    },
+    components: {
+      schemas: {
+        Health: {
+          type: "object",
+          properties: { status: { type: "string" }, uptime: { type: "number" }, version: { type: "string" } }
+        },
+        Status: {
+          type: "object",
+          properties: { isRunning: { type: "boolean" }, sessionId: { type: "string" } }
+        },
+        Session: {
+          type: "object",
+          properties: {
+            id: { type: "string" },
+            started_at: { type: "string", format: "date-time" },
+            ended_at: { type: "string", format: "date-time", nullable: true },
+            status: { type: "string", enum: ["running", "completed", "failed"] },
+            total_actions: { type: "integer" },
+            bugs_found: { type: "integer" }
+          }
+        },
+        Action: {
+          type: "object",
+          properties: {
+            id: { type: "string" },
+            session_id: { type: "string" },
+            timestamp: { type: "string", format: "date-time" },
+            type: { type: "string" },
+            description: { type: "string" }
+          }
+        },
+        Bug: {
+          type: "object",
+          properties: {
+            id: { type: "string" },
+            session_id: { type: "string" },
+            title: { type: "string" },
+            description: { type: "string" },
+            severity: { type: "string", enum: ["low", "medium", "high", "critical"] },
+            status: { type: "string", enum: ["open", "in-progress", "resolved", "closed"] },
+            github_issue_url: { type: "string", nullable: true },
+            created_at: { type: "string", format: "date-time" }
+          }
+        },
+        KanbanTicket: {
+          type: "object",
+          properties: {
+            id: { type: "string" },
+            title: { type: "string" },
+            description: { type: "string" },
+            priority: { type: "string", enum: ["low", "medium", "high", "critical"] },
+            column: { type: "string", enum: ["backlog", "to-do", "in-progress", "done"] },
+            created_at: { type: "string", format: "date-time" }
+          }
+        },
+        KanbanTicketInput: {
+          type: "object",
+          properties: {
+            title: { type: "string" },
+            description: { type: "string" },
+            priority: { type: "string", enum: ["low", "medium", "high", "critical"] },
+            column: { type: "string", enum: ["backlog", "to-do", "in-progress", "done"] }
+          }
+        },
+        ProjectStatus: {
+          type: "object",
+          properties: {
+            repoPath: { type: "string" },
+            installed: { type: "boolean" },
+            serverRunning: { type: "boolean" },
+            serverUrl: { type: "string", nullable: true },
+            serverPid: { type: "integer", nullable: true }
+          }
+        },
+        TestRunResult: {
+          type: "object",
+          properties: {
+            runner: { type: "string" },
+            passed: { type: "integer" },
+            failed: { type: "integer" },
+            skipped: { type: "integer" },
+            total: { type: "integer" },
+            durationMs: { type: "integer" }
+          }
+        },
+        CoverageReport: {
+          type: "object",
+          properties: {
+            total: { type: "integer" },
+            tested: { type: "integer" },
+            untested: { type: "integer" },
+            coveragePercent: { type: "integer" },
+            entries: { type: "array", items: { type: "object", properties: { url: { type: "string" }, method: { type: "string" }, tested: { type: "boolean" }, testCount: { type: "integer" } } } }
+          }
+        },
+        SuccessResponse: {
+          type: "object",
+          properties: { success: { type: "boolean" } }
+        }
+      }
+    }
+  };
+}
+
+// agent/metrics.ts
+init_esm_shims();
+var startedAt = Date.now();
+var counters = {
+  llm_calls: 0,
+  llm_cache_hits: 0,
+  llm_retries: 0,
+  llm_fallbacks: 0,
+  llm_circuit_opens: 0,
+  tests_generated: 0,
+  tests_run: 0,
+  tests_passed: 0,
+  tests_failed: 0,
+  bugs_found: 0,
+  sessions_started: 0,
+  ws_connections: 0,
+  http_requests: 0
+};
+var metrics = {
+  inc(key, by = 1) {
+    if (key in counters) counters[key] += by;
+  },
+  snapshot() {
+    const memMB = process.memoryUsage();
+    return {
+      uptimeSeconds: Math.floor((Date.now() - startedAt) / 1e3),
+      memory: {
+        heapUsedMB: Math.round(memMB.heapUsed / 1024 / 1024),
+        heapTotalMB: Math.round(memMB.heapTotal / 1024 / 1024),
+        rssMB: Math.round(memMB.rss / 1024 / 1024)
+      },
+      counters: { ...counters },
+      cacheHitRate: counters.llm_calls > 0 ? Math.round(counters.llm_cache_hits / (counters.llm_calls + counters.llm_cache_hits) * 100) : 0
+    };
+  }
+};
+
+// cli/routes.ts
+function validate(schema) {
+  return (req, res, next) => {
+    const result = schema.safeParse(req.body);
+    if (!result.success) {
+      return res.status(400).json({
+        error: result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join(", ")
+      });
+    }
+    req.body = result.data;
+    next();
+  };
+}
+var kanbanCreateSchema = z.object({
+  title: z.string().min(1).max(200).optional(),
+  description: z.string().max(2e3).optional(),
+  priority: z.enum(["low", "medium", "high", "critical"]).optional(),
+  column: z.enum(["backlog", "todo", "in_progress", "done"]).optional()
+});
+var kanbanUpdateSchema = z.object({
+  title: z.string().min(1).max(200).optional(),
+  description: z.string().max(2e3).optional(),
+  priority: z.enum(["low", "medium", "high", "critical"]).optional(),
+  column: z.enum(["backlog", "todo", "in_progress", "done"]).optional(),
+  assignee: z.string().max(100).optional(),
+  tags: z.array(z.string().max(50)).max(20).optional()
+}).loose();
+var configUpdateSchema = z.record(
+  z.string(),
+  z.union([z.string(), z.number(), z.boolean(), z.record(z.string(), z.unknown())])
+);
+var exportFormatSchema = z.enum(["json", "csv", "html"]);
+function createApiRouter(db, config) {
+  const router = Router();
+  router.use((_req, _res, next) => {
+    metrics.inc("http_requests");
+    next();
+  });
+  router.get("/health", async (_req, res) => {
+    const snap = metrics.snapshot();
+    let dbOk = false;
+    try {
+      await db.getStorageStats();
+      dbOk = true;
+    } catch {
+    }
+    res.json({
+      status: dbOk ? "ok" : "degraded",
+      version: "1.3.4",
+      uptime: snap.uptimeSeconds,
+      memory: snap.memory,
+      db: dbOk
+    });
+  });
+  router.get("/api/metrics", (_req, res) => {
+    res.json(metrics.snapshot());
+  });
+  router.get("/api/status", (_req, res) => {
+    res.json({ isRunning: true });
+  });
+  router.get("/api/sessions", async (req, res) => {
+    const limit = parseInt(req.query.limit) || 10;
+    const sessions = await db.getRecentSessions(limit);
+    res.json(sessions);
+  });
+  router.get("/api/sessions/:id/actions", async (req, res) => {
+    const actions = await db.getSessionActions(req.params.id);
+    res.json(actions);
+  });
+  router.get("/api/bugs", async (req, res) => {
+    const status = req.query.status;
+    const bugs = status ? await db.getBugsByStatus(status) : await db.getAllBugs();
+    res.json(bugs);
+  });
+  router.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);
+  });
+  router.get("/api/kanban", async (_req, res) => {
+    const tickets = await db.getKanbanTickets();
+    res.json(tickets);
+  });
+  router.post("/api/kanban", validate(kanbanCreateSchema), async (req, res) => {
+    try {
+      const { title, description, priority, column } = req.body;
+      const ticket = await db.createKanbanTicket({
+        title: title || "New Ticket",
+        description: description || "",
+        priority: priority || "medium",
+        column: column || "backlog"
+      });
+      res.json(ticket);
+    } catch (error) {
+      res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
+    }
+  });
+  router.put("/api/kanban/:id", validate(kanbanUpdateSchema), async (req, res) => {
+    try {
+      const { id } = req.params;
+      const updates = req.body;
+      await db.updateKanbanTicket(id, updates);
+      res.json({ success: true });
+    } catch (error) {
+      res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
+    }
+  });
+  router.delete("/api/kanban/:id", async (req, res) => {
+    try {
+      const { id } = req.params;
+      await db.deleteKanbanTicket(id);
+      res.json({ success: true });
+    } catch (error) {
+      res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
+    }
+  });
+  router.patch("/api/kanban/tickets/:id", validate(kanbanUpdateSchema), async (req, res) => {
+    const { id } = req.params;
+    const updates = req.body;
+    await db.updateKanbanTicket(id, updates);
+    res.json({ success: true });
+  });
+  router.get("/api/config", async (_req, res) => {
+    const cfg = await config.getConfig();
+    res.json(JSON.parse(JSON.stringify(cfg)));
+  });
+  router.post("/api/config", validate(configUpdateSchema), async (req, res) => {
+    try {
+      const configData = req.body;
+      for (const [section, values] of Object.entries(configData)) {
+        if (typeof values === "object" && values !== null) {
+          for (const [key, value] of Object.entries(values)) {
+            await config.set(`${section}.${key}`, String(value));
+          }
+        } else {
+          await config.set(section, String(values));
+        }
+      }
+      res.json({ success: true });
+    } catch (error) {
+      res.status(500).json({ success: false, error: error instanceof Error ? error.message : String(error) });
+    }
+  });
+  router.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 instanceof Error ? error.message : String(error) });
+    }
+  });
+  router.post("/api/test-connection", async (req, res) => {
+    const urlStr = req.body.url;
+    if (!urlStr) {
+      return res.status(400).json({ success: false, error: "url is required" });
+    }
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), 5e3);
+      const response = await fetch(urlStr, {
+        method: "HEAD",
+        signal: controller.signal,
+        redirect: "follow"
+      });
+      clearTimeout(timeoutId);
+      res.json({ success: true, status: response.status, ok: response.ok });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      res.status(200).json({ success: false, error: message });
+    }
+  });
+  router.get("/api/openapi.json", (_req, res) => {
+    res.json(getOpenAPISpec());
+  });
+  router.get("/api/docs", (_req, res) => {
+    const spec = JSON.stringify(getOpenAPISpec());
+    res.setHeader("Content-Type", "text/html");
+    res.send(`<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>OpenQA API Docs</title>
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <link rel="stylesheet" href="https://unpkg.com/swagger-ui-dist@5/swagger-ui.css">
+</head>
+<body>
+  <div id="swagger-ui"></div>
+  <script src="https://unpkg.com/swagger-ui-dist@5/swagger-ui-bundle.js"></script>
+  <script>
+    SwaggerUIBundle({ spec: ${spec}, dom_id: '#swagger-ui', presets: [SwaggerUIBundle.presets.apis, SwaggerUIBundle.SwaggerUIStandalonePreset], layout: 'BaseLayout' });
+  </script>
+</body>
+</html>`);
+  });
+  router.get("/api/coverage/:sessionId", async (req, res) => {
+    try {
+      const { CoverageTracker: CoverageTracker2 } = await Promise.resolve().then(() => (init_coverage(), coverage_exports));
+      const tracker = new CoverageTracker2();
+      await tracker.loadFromDatabase(db, req.params.sessionId);
+      res.json(tracker.getReport());
+    } catch (error) {
+      res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
+    }
+  });
+  router.post("/api/cleanup", async (req, res) => {
+    try {
+      const maxAgeDays = parseInt(req.query.maxAgeDays) || 30;
+      const result = await db.pruneOldSessions(maxAgeDays);
+      res.json({ success: true, ...result });
+    } catch (error) {
+      res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
+    }
+  });
+  router.get("/api/storage", async (_req, res) => {
+    try {
+      const stats = await db.getStorageStats();
+      res.json(stats);
+    } catch (error) {
+      res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
+    }
+  });
+  router.get("/api/export/:sessionId", async (req, res) => {
+    try {
+      const { sessionId } = req.params;
+      const fmtResult = exportFormatSchema.safeParse(req.query.format || "json");
+      if (!fmtResult.success) {
+        return res.status(400).json({ error: "Invalid format. Use json, csv, or html." });
+      }
+      const format = fmtResult.data;
+      const exportService = new ExportService(db);
+      const result = await exportService.exportSession(sessionId, format);
+      res.setHeader("Content-Type", result.contentType);
+      res.setHeader("Content-Disposition", `attachment; filename="${result.filename}"`);
+      res.send(result.content);
+    } catch (error) {
+      res.status(404).json({ error: error instanceof Error ? error.message : String(error) });
+    }
+  });
+  router.get("/api/tasks", async (_req, res) => {
+    try {
+      const tasks = await db.getCurrentTasks();
+      res.json(tasks);
+    } catch (error) {
+      res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
+    }
+  });
+  router.get("/api/issues", async (_req, res) => {
+    try {
+      const issues = await db.getCurrentIssues();
+      res.json(issues);
+    } catch (error) {
+      res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
+    }
+  });
+  return router;
+}
+export {
+  createApiRouter
+};
+//# sourceMappingURL=routes.js.map