@openqa/cli 2.0.0 → 2.1.1

package/dist/cli/env-routes.js

@@ -0,0 +1,820 @@
+// cli/env-routes.ts
+import { Router } from "express";
+import { readFileSync, writeFileSync, existsSync } from "fs";
+import { join } from "path";
+
+// cli/env-config.ts
+var ENV_VARIABLES = [
+  // ============================================================================
+  // LLM CONFIGURATION
+  // ============================================================================
+  {
+    key: "LLM_PROVIDER",
+    type: "select",
+    category: "llm",
+    required: true,
+    description: "LLM provider to use for AI operations",
+    options: ["openai", "anthropic", "ollama"],
+    placeholder: "openai",
+    restartRequired: true
+  },
+  {
+    key: "OPENAI_API_KEY",
+    type: "password",
+    category: "llm",
+    required: false,
+    description: "OpenAI API key (required if LLM_PROVIDER=openai)",
+    placeholder: "sk-...",
+    sensitive: true,
+    testable: true,
+    validation: (value) => {
+      if (!value) return { valid: true };
+      if (!value.startsWith("sk-")) {
+        return { valid: false, error: 'OpenAI API key must start with "sk-"' };
+      }
+      if (value.length < 20) {
+        return { valid: false, error: "API key seems too short" };
+      }
+      return { valid: true };
+    },
+    restartRequired: true
+  },
+  {
+    key: "ANTHROPIC_API_KEY",
+    type: "password",
+    category: "llm",
+    required: false,
+    description: "Anthropic API key (required if LLM_PROVIDER=anthropic)",
+    placeholder: "sk-ant-...",
+    sensitive: true,
+    testable: true,
+    validation: (value) => {
+      if (!value) return { valid: true };
+      if (!value.startsWith("sk-ant-")) {
+        return { valid: false, error: 'Anthropic API key must start with "sk-ant-"' };
+      }
+      return { valid: true };
+    },
+    restartRequired: true
+  },
+  {
+    key: "OLLAMA_BASE_URL",
+    type: "url",
+    category: "llm",
+    required: false,
+    description: "Ollama server URL (required if LLM_PROVIDER=ollama)",
+    placeholder: "http://localhost:11434",
+    testable: true,
+    validation: (value) => {
+      if (!value) return { valid: true };
+      try {
+        new URL(value);
+        return { valid: true };
+      } catch {
+        return { valid: false, error: "Invalid URL format" };
+      }
+    },
+    restartRequired: true
+  },
+  {
+    key: "LLM_MODEL",
+    type: "text",
+    category: "llm",
+    required: false,
+    description: "LLM model to use (e.g., gpt-4, claude-3-opus, llama2)",
+    placeholder: "gpt-4",
+    restartRequired: true
+  },
+  // ============================================================================
+  // SECURITY
+  // ============================================================================
+  {
+    key: "OPENQA_JWT_SECRET",
+    type: "password",
+    category: "security",
+    required: true,
+    description: "Secret key for JWT token signing (min 32 characters)",
+    placeholder: "Generate with: openssl rand -hex 32",
+    sensitive: true,
+    validation: (value) => {
+      if (!value) return { valid: false, error: "JWT secret is required" };
+      if (value.length < 32) {
+        return { valid: false, error: "JWT secret must be at least 32 characters" };
+      }
+      return { valid: true };
+    },
+    restartRequired: true
+  },
+  {
+    key: "OPENQA_AUTH_DISABLED",
+    type: "boolean",
+    category: "security",
+    required: false,
+    description: "\u26A0\uFE0F DANGER: Disable authentication (NEVER use in production!)",
+    placeholder: "false",
+    validation: (value) => {
+      if (value === "true" && process.env.NODE_ENV === "production") {
+        return { valid: false, error: "Cannot disable auth in production!" };
+      }
+      return { valid: true };
+    },
+    restartRequired: true
+  },
+  {
+    key: "NODE_ENV",
+    type: "select",
+    category: "security",
+    required: false,
+    description: "Node environment (production enables security features)",
+    options: ["development", "production", "test"],
+    placeholder: "production",
+    restartRequired: true
+  },
+  // ============================================================================
+  // TARGET APPLICATION
+  // ============================================================================
+  {
+    key: "SAAS_URL",
+    type: "url",
+    category: "target",
+    required: true,
+    description: "URL of the application to test",
+    placeholder: "https://your-app.com",
+    testable: true,
+    validation: (value) => {
+      if (!value) return { valid: false, error: "Target URL is required" };
+      try {
+        const url = new URL(value);
+        if (!["http:", "https:"].includes(url.protocol)) {
+          return { valid: false, error: "URL must use http or https protocol" };
+        }
+        return { valid: true };
+      } catch {
+        return { valid: false, error: "Invalid URL format" };
+      }
+    }
+  },
+  {
+    key: "SAAS_AUTH_TYPE",
+    type: "select",
+    category: "target",
+    required: false,
+    description: "Authentication type for target application",
+    options: ["none", "basic", "session"],
+    placeholder: "none"
+  },
+  {
+    key: "SAAS_USERNAME",
+    type: "text",
+    category: "target",
+    required: false,
+    description: "Username for target application authentication",
+    placeholder: "test@example.com"
+  },
+  {
+    key: "SAAS_PASSWORD",
+    type: "password",
+    category: "target",
+    required: false,
+    description: "Password for target application authentication",
+    placeholder: "\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022",
+    sensitive: true
+  },
+  // ============================================================================
+  // GITHUB INTEGRATION
+  // ============================================================================
+  {
+    key: "GITHUB_TOKEN",
+    type: "password",
+    category: "github",
+    required: false,
+    description: "GitHub personal access token for issue creation",
+    placeholder: "ghp_...",
+    sensitive: true,
+    testable: true,
+    validation: (value) => {
+      if (!value) return { valid: true };
+      if (!value.startsWith("ghp_") && !value.startsWith("github_pat_")) {
+        return { valid: false, error: 'GitHub token must start with "ghp_" or "github_pat_"' };
+      }
+      return { valid: true };
+    }
+  },
+  {
+    key: "GITHUB_OWNER",
+    type: "text",
+    category: "github",
+    required: false,
+    description: "GitHub repository owner/organization",
+    placeholder: "your-username"
+  },
+  {
+    key: "GITHUB_REPO",
+    type: "text",
+    category: "github",
+    required: false,
+    description: "GitHub repository name",
+    placeholder: "your-repo"
+  },
+  {
+    key: "GITHUB_BRANCH",
+    type: "text",
+    category: "github",
+    required: false,
+    description: "GitHub branch to monitor",
+    placeholder: "main"
+  },
+  // ============================================================================
+  // WEB SERVER
+  // ============================================================================
+  {
+    key: "WEB_PORT",
+    type: "number",
+    category: "web",
+    required: false,
+    description: "Port for web server",
+    placeholder: "4242",
+    validation: (value) => {
+      if (!value) return { valid: true };
+      const port = parseInt(value, 10);
+      if (isNaN(port) || port < 1 || port > 65535) {
+        return { valid: false, error: "Port must be between 1 and 65535" };
+      }
+      return { valid: true };
+    },
+    restartRequired: true
+  },
+  {
+    key: "WEB_HOST",
+    type: "text",
+    category: "web",
+    required: false,
+    description: "Host to bind web server (0.0.0.0 for all interfaces)",
+    placeholder: "0.0.0.0",
+    restartRequired: true
+  },
+  {
+    key: "CORS_ORIGINS",
+    type: "text",
+    category: "web",
+    required: false,
+    description: "Allowed CORS origins (comma-separated)",
+    placeholder: "https://your-domain.com,https://app.example.com",
+    restartRequired: true
+  },
+  // ============================================================================
+  // AGENT CONFIGURATION
+  // ============================================================================
+  {
+    key: "AGENT_AUTO_START",
+    type: "boolean",
+    category: "agent",
+    required: false,
+    description: "Auto-start agent on server launch",
+    placeholder: "false"
+  },
+  {
+    key: "AGENT_INTERVAL_MS",
+    type: "number",
+    category: "agent",
+    required: false,
+    description: "Agent run interval in milliseconds (1 hour = 3600000)",
+    placeholder: "3600000",
+    validation: (value) => {
+      if (!value) return { valid: true };
+      const interval = parseInt(value, 10);
+      if (isNaN(interval) || interval < 6e4) {
+        return { valid: false, error: "Interval must be at least 60000ms (1 minute)" };
+      }
+      return { valid: true };
+    }
+  },
+  {
+    key: "AGENT_MAX_ITERATIONS",
+    type: "number",
+    category: "agent",
+    required: false,
+    description: "Maximum iterations per agent session",
+    placeholder: "20",
+    validation: (value) => {
+      if (!value) return { valid: true };
+      const max = parseInt(value, 10);
+      if (isNaN(max) || max < 1 || max > 1e3) {
+        return { valid: false, error: "Max iterations must be between 1 and 1000" };
+      }
+      return { valid: true };
+    }
+  },
+  {
+    key: "GIT_LISTENER_ENABLED",
+    type: "boolean",
+    category: "agent",
+    required: false,
+    description: "Enable git merge/pipeline detection",
+    placeholder: "true"
+  },
+  {
+    key: "GIT_POLL_INTERVAL_MS",
+    type: "number",
+    category: "agent",
+    required: false,
+    description: "Git polling interval in milliseconds",
+    placeholder: "60000"
+  },
+  // ============================================================================
+  // DATABASE
+  // ============================================================================
+  {
+    key: "DB_PATH",
+    type: "text",
+    category: "database",
+    required: false,
+    description: "Path to SQLite database file",
+    placeholder: "./data/openqa.db",
+    restartRequired: true
+  },
+  // ============================================================================
+  // NOTIFICATIONS
+  // ============================================================================
+  {
+    key: "SLACK_WEBHOOK_URL",
+    type: "url",
+    category: "notifications",
+    required: false,
+    description: "Slack webhook URL for notifications",
+    placeholder: "https://hooks.slack.com/services/...",
+    sensitive: true,
+    testable: true,
+    validation: (value) => {
+      if (!value) return { valid: true };
+      if (!value.startsWith("https://hooks.slack.com/")) {
+        return { valid: false, error: "Invalid Slack webhook URL" };
+      }
+      return { valid: true };
+    }
+  },
+  {
+    key: "DISCORD_WEBHOOK_URL",
+    type: "url",
+    category: "notifications",
+    required: false,
+    description: "Discord webhook URL for notifications",
+    placeholder: "https://discord.com/api/webhooks/...",
+    sensitive: true,
+    testable: true,
+    validation: (value) => {
+      if (!value) return { valid: true };
+      if (!value.startsWith("https://discord.com/api/webhooks/")) {
+        return { valid: false, error: "Invalid Discord webhook URL" };
+      }
+      return { valid: true };
+    }
+  }
+];
+function getEnvVariable(key) {
+  return ENV_VARIABLES.find((v) => v.key === key);
+}
+function validateEnvValue(key, value) {
+  const envVar = getEnvVariable(key);
+  if (!envVar) return { valid: false, error: "Unknown environment variable" };
+  if (envVar.required && !value) {
+    return { valid: false, error: "This field is required" };
+  }
+  if (envVar.validation) {
+    return envVar.validation(value);
+  }
+  return { valid: true };
+}
+
+// cli/auth/jwt.ts
+import { createHmac, randomBytes } from "crypto";
+import { parse as parseCookies } from "cookie";
+var TTL_MS = 24 * 60 * 60 * 1e3;
+var COOKIE_NAME = "openqa_token";
+var _secret = null;
+function getSecret() {
+  if (_secret) return _secret;
+  _secret = process.env.OPENQA_JWT_SECRET ?? null;
+  if (!_secret) {
+    _secret = randomBytes(32).toString("hex");
+    console.warn("[OpenQA] OPENQA_JWT_SECRET not set \u2014 using a volatile secret. All sessions will be invalidated on restart.");
+  }
+  return _secret;
+}
+function fromB64url(input) {
+  return Buffer.from(input, "base64url").toString("utf8");
+}
+function verifyToken(token) {
+  try {
+    const [header, body, sig] = token.split(".");
+    if (!header || !body || !sig) return null;
+    const expected = createHmac("sha256", getSecret()).update(`${header}.${body}`).digest("base64url");
+    if (expected !== sig) return null;
+    const payload = JSON.parse(fromB64url(body));
+    if (payload.exp < Math.floor(Date.now() / 1e3)) return null;
+    return payload;
+  } catch {
+    return null;
+  }
+}
+function extractToken(req) {
+  const cookieHeader = req.headers.cookie ?? "";
+  if (cookieHeader) {
+    const cookies = parseCookies(cookieHeader);
+    if (cookies[COOKIE_NAME]) return cookies[COOKIE_NAME];
+  }
+  const auth = req.headers.authorization ?? "";
+  if (auth.startsWith("Bearer ")) return auth.slice(7);
+  return null;
+}
+
+// cli/auth/middleware.ts
+var AUTH_DISABLED = process.env.OPENQA_AUTH_DISABLED === "true";
+function requireAuth(req, res, next) {
+  if (AUTH_DISABLED) {
+    req.user = { sub: "dev", username: "dev", role: "admin", iat: 0, exp: 0 };
+    return next();
+  }
+  const token = extractToken(req);
+  const payload = token ? verifyToken(token) : null;
+  if (!payload) {
+    res.status(401).json({ error: "Unauthorized" });
+    return;
+  }
+  req.user = payload;
+  next();
+}
+function requireAdmin(req, res, next) {
+  const user = req.user;
+  if (!user || user.role !== "admin") {
+    res.status(403).json({ error: "Forbidden \u2014 admin only" });
+    return;
+  }
+  next();
+}
+
+// cli/env-routes.ts
+function createEnvRouter() {
+  const router = Router();
+  const ENV_FILE_PATH = join(process.cwd(), ".env");
+  function readEnvFile() {
+    if (!existsSync(ENV_FILE_PATH)) {
+      return {};
+    }
+    const content = readFileSync(ENV_FILE_PATH, "utf-8");
+    const env = {};
+    content.split("\n").forEach((line) => {
+      line = line.trim();
+      if (!line || line.startsWith("#")) return;
+      const match = line.match(/^([^=]+)=(.*)$/);
+      if (match) {
+        const [, key, value] = match;
+        env[key.trim()] = value.trim().replace(/^["']|["']$/g, "");
+      }
+    });
+    return env;
+  }
+  function writeEnvFile(env) {
+    const lines = [
+      "# OpenQA Environment Configuration",
+      "# Auto-generated by OpenQA Dashboard",
+      "# Last updated: " + (/* @__PURE__ */ new Date()).toISOString(),
+      ""
+    ];
+    const categories = {};
+    ENV_VARIABLES.forEach((v) => {
+      if (!categories[v.category]) {
+        categories[v.category] = [];
+      }
+      const value = env[v.key] || "";
+      if (value || v.required) {
+        categories[v.category].push(`${v.key}=${value}`);
+      }
+    });
+    const categoryNames = {
+      llm: "LLM CONFIGURATION",
+      security: "SECURITY",
+      target: "TARGET APPLICATION",
+      github: "GITHUB INTEGRATION",
+      web: "WEB SERVER",
+      agent: "AGENT CONFIGURATION",
+      database: "DATABASE",
+      notifications: "NOTIFICATIONS"
+    };
+    Object.entries(categories).forEach(([category, vars]) => {
+      if (vars.length > 0) {
+        lines.push("# " + "=".repeat(76));
+        lines.push(`# ${categoryNames[category] || category.toUpperCase()}`);
+        lines.push("# " + "=".repeat(76));
+        lines.push(...vars);
+        lines.push("");
+      }
+    });
+    writeFileSync(ENV_FILE_PATH, lines.join("\n"));
+  }
+  router.get("/api/env", requireAuth, requireAdmin, (_req, res) => {
+    try {
+      const envFile = readEnvFile();
+      const processEnv = process.env;
+      const variables = ENV_VARIABLES.map((v) => ({
+        key: v.key,
+        value: envFile[v.key] || processEnv[v.key] || "",
+        type: v.type,
+        category: v.category,
+        required: v.required,
+        description: v.description,
+        placeholder: v.placeholder,
+        options: v.options,
+        sensitive: v.sensitive,
+        testable: v.testable,
+        restartRequired: v.restartRequired,
+        // Mask sensitive values
+        displayValue: v.sensitive && (envFile[v.key] || processEnv[v.key]) ? "\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022" : envFile[v.key] || processEnv[v.key] || ""
+      }));
+      res.json({
+        variables,
+        envFileExists: existsSync(ENV_FILE_PATH),
+        lastModified: existsSync(ENV_FILE_PATH) ? new Date(readFileSync(ENV_FILE_PATH, "utf-8").match(/Last updated: (.+)/)?.[1] || 0).toISOString() : null
+      });
+    } catch (error) {
+      res.status(500).json({
+        error: "Failed to read environment variables",
+        details: error instanceof Error ? error.message : String(error)
+      });
+    }
+  });
+  router.get("/api/env/:key", requireAuth, requireAdmin, (req, res) => {
+    try {
+      const { key } = req.params;
+      const envVar = ENV_VARIABLES.find((v) => v.key === key);
+      if (!envVar) {
+        res.status(404).json({ error: "Environment variable not found" });
+        return;
+      }
+      const envFile = readEnvFile();
+      const value = envFile[key] || process.env[key] || "";
+      res.json({
+        ...envVar,
+        value,
+        displayValue: envVar.sensitive && value ? "\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022" : value
+      });
+    } catch (error) {
+      res.status(500).json({
+        error: "Failed to read environment variable",
+        details: error instanceof Error ? error.message : String(error)
+      });
+    }
+  });
+  router.put("/api/env/:key", requireAuth, requireAdmin, (req, res) => {
+    try {
+      const { key } = req.params;
+      const { value } = req.body;
+      const validation = validateEnvValue(key, value);
+      if (!validation.valid) {
+        res.status(400).json({ error: validation.error });
+        return;
+      }
+      const env = readEnvFile();
+      if (value === "" || value === null || value === void 0) {
+        delete env[key];
+      } else {
+        env[key] = value;
+      }
+      writeEnvFile(env);
+      if (value) {
+        process.env[key] = value;
+      } else {
+        delete process.env[key];
+      }
+      const envVar = ENV_VARIABLES.find((v) => v.key === key);
+      res.json({
+        success: true,
+        key,
+        value: envVar?.sensitive ? "\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022" : value,
+        restartRequired: envVar?.restartRequired || false
+      });
+    } catch (error) {
+      res.status(500).json({
+        error: "Failed to update environment variable",
+        details: error instanceof Error ? error.message : String(error)
+      });
+    }
+  });
+  router.post("/api/env/bulk", requireAuth, requireAdmin, (req, res) => {
+    try {
+      const { variables } = req.body;
+      if (!variables || typeof variables !== "object") {
+        res.status(400).json({ error: "Invalid request body" });
+        return;
+      }
+      const errors = {};
+      Object.entries(variables).forEach(([key, value]) => {
+        const validation = validateEnvValue(key, value);
+        if (!validation.valid) {
+          errors[key] = validation.error || "Invalid value";
+        }
+      });
+      if (Object.keys(errors).length > 0) {
+        res.status(400).json({ error: "Validation failed", errors });
+        return;
+      }
+      const env = readEnvFile();
+      Object.entries(variables).forEach(([key, value]) => {
+        if (value === "" || value === null || value === void 0) {
+          delete env[key];
+          delete process.env[key];
+        } else {
+          env[key] = value;
+          process.env[key] = value;
+        }
+      });
+      writeEnvFile(env);
+      const restartRequired = Object.keys(variables).some((key) => {
+        const envVar = ENV_VARIABLES.find((v) => v.key === key);
+        return envVar?.restartRequired;
+      });
+      res.json({
+        success: true,
+        updated: Object.keys(variables).length,
+        restartRequired
+      });
+    } catch (error) {
+      res.status(500).json({
+        error: "Failed to update environment variables",
+        details: error instanceof Error ? error.message : String(error)
+      });
+    }
+  });
+  router.post("/api/env/test/:key", requireAuth, requireAdmin, async (req, res) => {
+    try {
+      const { key } = req.params;
+      const { value } = req.body;
+      const envVar = ENV_VARIABLES.find((v) => v.key === key);
+      if (!envVar || !envVar.testable) {
+        res.status(400).json({ error: "This variable cannot be tested" });
+        return;
+      }
+      let testResult;
+      switch (key) {
+        case "OPENAI_API_KEY":
+          testResult = await testOpenAIKey(value);
+          break;
+        case "ANTHROPIC_API_KEY":
+          testResult = await testAnthropicKey(value);
+          break;
+        case "OLLAMA_BASE_URL":
+          testResult = await testOllamaURL(value);
+          break;
+        case "GITHUB_TOKEN":
+          testResult = await testGitHubToken(value);
+          break;
+        case "SAAS_URL":
+          testResult = await testURL(value);
+          break;
+        case "SLACK_WEBHOOK_URL":
+          testResult = await testSlackWebhook(value);
+          break;
+        case "DISCORD_WEBHOOK_URL":
+          testResult = await testDiscordWebhook(value);
+          break;
+        default:
+          testResult = { success: false, message: "Test not implemented for this variable" };
+      }
+      res.json(testResult);
+    } catch (error) {
+      res.status(500).json({
+        success: false,
+        message: error instanceof Error ? error.message : "Test failed"
+      });
+    }
+  });
+  router.post("/api/env/generate/:key", requireAuth, requireAdmin, (req, res) => {
+    try {
+      const { key } = req.params;
+      let generated;
+      switch (key) {
+        case "OPENQA_JWT_SECRET":
+          generated = Array.from(
+            { length: 64 },
+            () => Math.floor(Math.random() * 16).toString(16)
+          ).join("");
+          break;
+        default:
+          res.status(400).json({ error: "Generation not supported for this variable" });
+          return;
+      }
+      res.json({ success: true, value: generated });
+    } catch (error) {
+      res.status(500).json({
+        error: "Failed to generate value",
+        details: error instanceof Error ? error.message : String(error)
+      });
+    }
+  });
+  return router;
+}
+async function testOpenAIKey(apiKey) {
+  try {
+    const response = await fetch("https://api.openai.com/v1/models", {
+      headers: { "Authorization": `Bearer ${apiKey}` }
+    });
+    if (response.ok) {
+      return { success: true, message: "OpenAI API key is valid" };
+    }
+    return { success: false, message: "Invalid OpenAI API key" };
+  } catch {
+    return { success: false, message: "Failed to connect to OpenAI API" };
+  }
+}
+async function testAnthropicKey(apiKey) {
+  try {
+    const response = await fetch("https://api.anthropic.com/v1/messages", {
+      method: "POST",
+      headers: {
+        "x-api-key": apiKey,
+        "anthropic-version": "2023-06-01",
+        "content-type": "application/json"
+      },
+      body: JSON.stringify({
+        model: "claude-3-haiku-20240307",
+        max_tokens: 1,
+        messages: [{ role: "user", content: "test" }]
+      })
+    });
+    if (response.status === 200 || response.status === 400) {
+      return { success: true, message: "Anthropic API key is valid" };
+    }
+    return { success: false, message: "Invalid Anthropic API key" };
+  } catch {
+    return { success: false, message: "Failed to connect to Anthropic API" };
+  }
+}
+async function testOllamaURL(url) {
+  try {
+    const response = await fetch(`${url}/api/tags`);
+    if (response.ok) {
+      return { success: true, message: "Ollama server is accessible" };
+    }
+    return { success: false, message: "Ollama server returned an error" };
+  } catch {
+    return { success: false, message: "Cannot connect to Ollama server" };
+  }
+}
+async function testGitHubToken(token) {
+  try {
+    const response = await fetch("https://api.github.com/user", {
+      headers: { "Authorization": `token ${token}` }
+    });
+    if (response.ok) {
+      const data = await response.json();
+      return { success: true, message: `GitHub token is valid (user: ${data.login})` };
+    }
+    return { success: false, message: "Invalid GitHub token" };
+  } catch {
+    return { success: false, message: "Failed to connect to GitHub API" };
+  }
+}
+async function testURL(url) {
+  try {
+    const response = await fetch(url, { method: "HEAD" });
+    if (response.ok) {
+      return { success: true, message: "URL is accessible" };
+    }
+    return { success: false, message: `URL returned status ${response.status}` };
+  } catch {
+    return { success: false, message: "Cannot connect to URL" };
+  }
+}
+async function testSlackWebhook(url) {
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ text: "OpenQA webhook test" })
+    });
+    if (response.ok) {
+      return { success: true, message: "Slack webhook is valid" };
+    }
+    return { success: false, message: "Invalid Slack webhook" };
+  } catch {
+    return { success: false, message: "Failed to connect to Slack webhook" };
+  }
+}
+async function testDiscordWebhook(url) {
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ content: "OpenQA webhook test" })
+    });
+    if (response.ok || response.status === 204) {
+      return { success: true, message: "Discord webhook is valid" };
+    }
+    return { success: false, message: "Invalid Discord webhook" };
+  } catch {
+    return { success: false, message: "Failed to connect to Discord webhook" };
+  }
+}
+export {
+  createEnvRouter
+};