@muggleai/mcp 1.0.17 → 1.0.18

package/dist/chunk-RXCZWOOD.js

@@ -0,0 +1,4823 @@
+import * as fs4 from 'fs';
+import * as os from 'os';
+import { platform } from 'os';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import winston from 'winston';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { ListToolsRequestSchema, CallToolRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { v4 } from 'uuid';
+import { z, ZodError } from 'zod';
+import axios, { AxiosError } from 'axios';
+import { exec } from 'child_process';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import * as fs6 from 'fs/promises';
+
+var __defProp = Object.defineProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var DEFAULT_PROMPT_SERVICE_URL = "https://promptservice.muggle-ai.com";
+var DEFAULT_WEB_SERVICE_URL = "http://localhost:3001";
+var DATA_DIR_NAME = ".muggle-ai";
+var ELECTRON_APP_DIR = "electron-app";
+var CREDENTIALS_FILE = "credentials.json";
+var DEFAULT_AUTH0_DOMAIN = "login.muggle-ai.com";
+var DEFAULT_AUTH0_CLIENT_ID = "UgG5UjoyLksxMciWWKqVpwfWrJ4rFvtT";
+var DEFAULT_AUTH0_AUDIENCE = "https://muggleai.us.auth0.com/api/v2/";
+var DEFAULT_AUTH0_SCOPE = "openid profile email offline_access";
+var configInstance = null;
+var muggleConfigCache = null;
+function getPackageRoot() {
+  const currentFilePath = fileURLToPath(import.meta.url);
+  const currentDir = path.dirname(currentFilePath);
+  if (currentDir.includes(path.join("dist", "shared"))) {
+    return path.resolve(currentDir, "..", "..");
+  }
+  if (currentDir.endsWith("dist")) {
+    return path.resolve(currentDir, "..");
+  }
+  if (currentDir.includes(path.join("src", "shared"))) {
+    return path.resolve(currentDir, "..", "..");
+  }
+  return path.dirname(currentDir);
+}
+function getMuggleConfig() {
+  if (muggleConfigCache) {
+    return muggleConfigCache;
+  }
+  const packageRoot = getPackageRoot();
+  const packageJsonPath = path.join(packageRoot, "package.json");
+  let packageJson;
+  try {
+    const content = fs4.readFileSync(packageJsonPath, "utf-8");
+    packageJson = JSON.parse(content);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `Failed to read package.json for muggleConfig.
+  Path: ${packageJsonPath}
+  Package root: ${packageRoot}
+  Error: ${errorMessage}
+  This is a bug - please report it.`
+    );
+  }
+  const config = packageJson.muggleConfig;
+  if (!config) {
+    throw new Error(
+      `Missing muggleConfig in package.json.
+  Path: ${packageJsonPath}
+  This is a bug - please report it.`
+    );
+  }
+  if (!config.electronAppVersion || typeof config.electronAppVersion !== "string") {
+    throw new Error(
+      `Missing or invalid muggleConfig.electronAppVersion in package.json.
+  Path: ${packageJsonPath}
+  Value: ${JSON.stringify(config.electronAppVersion)}
+  This is a bug - please report it.`
+    );
+  }
+  if (!config.downloadBaseUrl || typeof config.downloadBaseUrl !== "string") {
+    throw new Error(
+      `Missing or invalid muggleConfig.downloadBaseUrl in package.json.
+  Path: ${packageJsonPath}
+  Value: ${JSON.stringify(config.downloadBaseUrl)}
+  This is a bug - please report it.`
+    );
+  }
+  muggleConfigCache = {
+    electronAppVersion: config.electronAppVersion,
+    downloadBaseUrl: config.downloadBaseUrl,
+    checksums: config.checksums || {}
+  };
+  return muggleConfigCache;
+}
+function getDataDir() {
+  return path.join(os.homedir(), DATA_DIR_NAME);
+}
+function getDownloadedElectronAppPath() {
+  const platform3 = os.platform();
+  const config = getMuggleConfig();
+  const version = config.electronAppVersion;
+  const baseDir = path.join(getDataDir(), ELECTRON_APP_DIR, version);
+  let binaryPath;
+  switch (platform3) {
+    case "darwin":
+      binaryPath = path.join(baseDir, "MuggleAI.app", "Contents", "MacOS", "MuggleAI");
+      break;
+    case "win32":
+      binaryPath = path.join(baseDir, "MuggleAI.exe");
+      break;
+    case "linux":
+      binaryPath = path.join(baseDir, "MuggleAI");
+      break;
+    default:
+      return null;
+  }
+  if (fs4.existsSync(binaryPath)) {
+    return binaryPath;
+  }
+  return null;
+}
+function getSystemElectronAppPath() {
+  const platform3 = os.platform();
+  const homeDir = os.homedir();
+  let binaryPath;
+  switch (platform3) {
+    case "darwin":
+      binaryPath = path.join(homeDir, "Applications", "MuggleAI.app", "Contents", "MacOS", "MuggleAI");
+      break;
+    case "win32":
+      binaryPath = path.join(homeDir, "AppData", "Local", "Programs", "MuggleAI", "MuggleAI.exe");
+      break;
+    case "linux":
+      binaryPath = path.join(homeDir, ".local", "share", "muggle-ai", "MuggleAI");
+      break;
+    default:
+      return null;
+  }
+  if (fs4.existsSync(binaryPath)) {
+    return binaryPath;
+  }
+  return null;
+}
+function resolveElectronAppPathOrNull() {
+  const customPath = process.env.ELECTRON_APP_PATH;
+  if (customPath && fs4.existsSync(customPath)) {
+    return customPath;
+  }
+  const downloadedPath = getDownloadedElectronAppPath();
+  if (downloadedPath) {
+    return downloadedPath;
+  }
+  const systemPath = getSystemElectronAppPath();
+  if (systemPath) {
+    return systemPath;
+  }
+  return null;
+}
+function resolveWebServicePath() {
+  const customPath = process.env.WEB_SERVICE_PATH;
+  if (customPath && fs4.existsSync(customPath)) {
+    return customPath;
+  }
+  const packageRoot = getPackageRoot();
+  const siblingPath = path.resolve(packageRoot, "..", "web-service", "dist", "src", "index.js");
+  if (fs4.existsSync(siblingPath)) {
+    return siblingPath;
+  }
+  return null;
+}
+function parseInteger(value, defaultValue) {
+  if (value === void 0 || value === "") {
+    return defaultValue;
+  }
+  const parsed = parseInt(value, 10);
+  return isNaN(parsed) ? defaultValue : parsed;
+}
+function buildAuth0Config() {
+  return {
+    domain: process.env.AUTH0_DOMAIN ?? DEFAULT_AUTH0_DOMAIN,
+    clientId: process.env.AUTH0_CLIENT_ID ?? DEFAULT_AUTH0_CLIENT_ID,
+    audience: process.env.AUTH0_AUDIENCE ?? DEFAULT_AUTH0_AUDIENCE,
+    scope: process.env.AUTH0_SCOPE ?? DEFAULT_AUTH0_SCOPE
+  };
+}
+function buildQaConfig() {
+  return {
+    promptServiceBaseUrl: process.env.PROMPT_SERVICE_BASE_URL ?? DEFAULT_PROMPT_SERVICE_URL,
+    requestTimeoutMs: parseInteger(process.env.REQUEST_TIMEOUT_MS, 3e4),
+    workflowTimeoutMs: parseInteger(process.env.WORKFLOW_TIMEOUT_MS, 12e4)
+  };
+}
+function buildLocalQaConfig() {
+  const dataDir = getDataDir();
+  const auth0Scopes = (process.env.AUTH0_SCOPE ?? DEFAULT_AUTH0_SCOPE).split(" ");
+  return {
+    webServiceUrl: process.env.WEB_SERVICE_URL ?? DEFAULT_WEB_SERVICE_URL,
+    promptServiceUrl: process.env.PROMPT_SERVICE_BASE_URL ?? DEFAULT_PROMPT_SERVICE_URL,
+    dataDir,
+    sessionsDir: path.join(dataDir, "sessions"),
+    projectsDir: path.join(dataDir, "projects"),
+    tempDir: path.join(dataDir, "temp"),
+    credentialsFilePath: path.join(dataDir, CREDENTIALS_FILE),
+    authFilePath: path.join(dataDir, "auth.json"),
+    electronAppPath: resolveElectronAppPathOrNull(),
+    webServicePath: resolveWebServicePath(),
+    webServicePidFile: path.join(dataDir, "web-service.pid"),
+    auth0: {
+      domain: process.env.AUTH0_DOMAIN ?? DEFAULT_AUTH0_DOMAIN,
+      clientId: process.env.AUTH0_CLIENT_ID ?? DEFAULT_AUTH0_CLIENT_ID,
+      audience: process.env.AUTH0_AUDIENCE ?? DEFAULT_AUTH0_AUDIENCE,
+      scopes: auth0Scopes
+    }
+  };
+}
+function getConfig() {
+  if (configInstance) {
+    return configInstance;
+  }
+  configInstance = {
+    serverName: "muggle-mcp",
+    serverVersion: "1.0.0",
+    logLevel: process.env.LOG_LEVEL ?? "info",
+    auth0: buildAuth0Config(),
+    qa: buildQaConfig(),
+    localQa: buildLocalQaConfig()
+  };
+  return configInstance;
+}
+function resetConfig() {
+  configInstance = null;
+  muggleConfigCache = null;
+}
+var VERSION_OVERRIDE_FILE = "electron-app-version-override.json";
+var ELECTRON_APP_VERSION_ENV = "ELECTRON_APP_VERSION";
+function getElectronAppVersion() {
+  const envVersion = process.env[ELECTRON_APP_VERSION_ENV];
+  if (envVersion && /^\d+\.\d+\.\d+$/.test(envVersion)) {
+    return envVersion;
+  }
+  const overridePath = path.join(getDataDir(), VERSION_OVERRIDE_FILE);
+  if (fs4.existsSync(overridePath)) {
+    try {
+      const content = JSON.parse(fs4.readFileSync(overridePath, "utf-8"));
+      if (content.version && typeof content.version === "string") {
+        return content.version;
+      }
+    } catch {
+    }
+  }
+  return getMuggleConfig().electronAppVersion;
+}
+function getElectronAppVersionSource() {
+  const envVersion = process.env[ELECTRON_APP_VERSION_ENV];
+  if (envVersion && /^\d+\.\d+\.\d+$/.test(envVersion)) {
+    return "env";
+  }
+  const overridePath = path.join(getDataDir(), VERSION_OVERRIDE_FILE);
+  if (fs4.existsSync(overridePath)) {
+    try {
+      const content = JSON.parse(fs4.readFileSync(overridePath, "utf-8"));
+      if (content.version && typeof content.version === "string") {
+        return "override";
+      }
+    } catch {
+    }
+  }
+  return "bundled";
+}
+function getBundledElectronAppVersion() {
+  return getMuggleConfig().electronAppVersion;
+}
+function getDownloadBaseUrl() {
+  return getMuggleConfig().downloadBaseUrl;
+}
+function getElectronAppChecksums() {
+  return getMuggleConfig().checksums;
+}
+function isElectronAppInstalled() {
+  return getDownloadedElectronAppPath() !== null;
+}
+function getElectronAppDir(version) {
+  const ver = version ?? getElectronAppVersion();
+  return path.join(getDataDir(), ELECTRON_APP_DIR, ver);
+}
+var loggerInstance = null;
+function createLogger() {
+  const config = getConfig();
+  const format = winston.format.combine(
+    winston.format.timestamp(),
+    winston.format.json()
+  );
+  return winston.createLogger({
+    level: config.logLevel,
+    format,
+    defaultMeta: {
+      service: config.serverName,
+      version: config.serverVersion
+    },
+    transports: [
+      // Log to stderr to avoid interfering with MCP stdio transport
+      new winston.transports.Console({
+        stderrLevels: ["error", "warn", "info", "http", "verbose", "debug", "silly"]
+      })
+    ]
+  });
+}
+function getLogger() {
+  if (!loggerInstance) {
+    loggerInstance = createLogger();
+  }
+  return loggerInstance;
+}
+function createChildLogger(correlationId) {
+  const logger5 = getLogger();
+  return logger5.child({ correlationId });
+}
+function resetLogger() {
+  loggerInstance = null;
+}
+var CREDENTIALS_FILE2 = "credentials.json";
+function getCredentialsFilePath() {
+  return path.join(getDataDir(), CREDENTIALS_FILE2);
+}
+function ensureDataDir() {
+  const dataDir = getDataDir();
+  if (!fs4.existsSync(dataDir)) {
+    fs4.mkdirSync(dataDir, { recursive: true });
+  }
+}
+function loadCredentials() {
+  const logger5 = getLogger();
+  const credentialsPath = getCredentialsFilePath();
+  try {
+    if (!fs4.existsSync(credentialsPath)) {
+      logger5.debug("No credentials file found", { path: credentialsPath });
+      return null;
+    }
+    const content = fs4.readFileSync(credentialsPath, "utf-8");
+    const credentials = JSON.parse(content);
+    if (!credentials.accessToken || !credentials.expiresAt) {
+      logger5.warn("Invalid credentials file - missing required fields");
+      return null;
+    }
+    return credentials;
+  } catch (error) {
+    logger5.warn("Failed to load credentials", {
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return null;
+  }
+}
+function saveCredentials(credentials) {
+  const logger5 = getLogger();
+  const credentialsPath = getCredentialsFilePath();
+  try {
+    ensureDataDir();
+    const content = JSON.stringify(credentials, null, 2);
+    fs4.writeFileSync(credentialsPath, content, { mode: 384 });
+    logger5.info("Credentials saved", { path: credentialsPath });
+  } catch (error) {
+    logger5.error("Failed to save credentials", {
+      error: error instanceof Error ? error.message : String(error)
+    });
+    throw error;
+  }
+}
+function deleteCredentials() {
+  const logger5 = getLogger();
+  const credentialsPath = getCredentialsFilePath();
+  try {
+    if (fs4.existsSync(credentialsPath)) {
+      fs4.unlinkSync(credentialsPath);
+      logger5.info("Credentials deleted", { path: credentialsPath });
+    }
+  } catch (error) {
+    logger5.warn("Failed to delete credentials", {
+      error: error instanceof Error ? error.message : String(error)
+    });
+  }
+}
+function isCredentialsExpired(credentials) {
+  const expiresAt = new Date(credentials.expiresAt);
+  const now = /* @__PURE__ */ new Date();
+  const bufferMs = 5 * 60 * 1e3;
+  return now.getTime() >= expiresAt.getTime() - bufferMs;
+}
+function getValidCredentials() {
+  const credentials = loadCredentials();
+  if (!credentials) {
+    return null;
+  }
+  if (isCredentialsExpired(credentials)) {
+    getLogger().info("Credentials expired", { expiresAt: credentials.expiresAt });
+    return null;
+  }
+  return credentials;
+}
+function getAuthStatus() {
+  const credentials = loadCredentials();
+  if (!credentials) {
+    return {
+      authenticated: false,
+      hasApiKey: false
+    };
+  }
+  const expired = isCredentialsExpired(credentials);
+  return {
+    authenticated: !expired,
+    email: credentials.email,
+    userId: credentials.userId,
+    expiresAt: credentials.expiresAt,
+    hasApiKey: !!credentials.apiKey
+  };
+}
+var logger = getLogger();
+function getOpenCommand(url) {
+  const plat = platform();
+  switch (plat) {
+    case "darwin":
+      return `open "${url}"`;
+    case "win32":
+      return `start "" "${url}"`;
+    case "linux":
+      return `xdg-open "${url}"`;
+    default:
+      throw new Error(`Unsupported platform: ${plat}`);
+  }
+}
+async function openBrowserUrl(options) {
+  return new Promise((resolve2) => {
+    try {
+      const command = getOpenCommand(options.url);
+      logger.debug("[Browser] Opening URL", { url: options.url, command });
+      exec(command, (error) => {
+        if (error) {
+          logger.warn("[Browser] Failed to open URL", {
+            url: options.url,
+            error: error.message
+          });
+          resolve2({
+            opened: false,
+            error: error.message
+          });
+        } else {
+          logger.info("[Browser] URL opened successfully", { url: options.url });
+          resolve2({ opened: true });
+        }
+      });
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      logger.warn("[Browser] Failed to open URL", {
+        url: options.url,
+        error: errorMessage
+      });
+      resolve2({
+        opened: false,
+        error: errorMessage
+      });
+    }
+  });
+}
+
+// src/shared/auth.ts
+var logger2 = getLogger();
+async function startDeviceCodeFlow(config) {
+  const deviceCodeUrl = `https://${config.domain}/oauth/device/code`;
+  try {
+    logger2.info("[Auth] Starting device code flow", {
+      domain: config.domain,
+      clientId: config.clientId
+    });
+    const response = await axios.post(
+      deviceCodeUrl,
+      new URLSearchParams({
+        client_id: config.clientId,
+        scope: config.scope,
+        audience: config.audience
+      }).toString(),
+      {
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded"
+        }
+      }
+    );
+    const data = response.data;
+    logger2.info("[Auth] Device code flow started successfully", {
+      userCode: data.user_code,
+      expiresIn: data.expires_in
+    });
+    const browserOpenResult = await openBrowserUrl({
+      url: data.verification_uri_complete
+    });
+    if (browserOpenResult.opened) {
+      logger2.info("[Auth] Browser opened for device code login");
+    } else {
+      logger2.warn("[Auth] Failed to open browser", {
+        error: browserOpenResult.error,
+        verificationUriComplete: data.verification_uri_complete
+      });
+    }
+    return {
+      deviceCode: data.device_code,
+      userCode: data.user_code,
+      verificationUri: data.verification_uri,
+      verificationUriComplete: data.verification_uri_complete,
+      expiresIn: data.expires_in,
+      interval: data.interval || 5,
+      browserOpened: browserOpenResult.opened,
+      browserOpenError: browserOpenResult.error
+    };
+  } catch (error) {
+    if (error instanceof AxiosError) {
+      logger2.error("[Auth] Failed to start device code flow", {
+        status: error.response?.status,
+        data: error.response?.data
+      });
+      throw new Error(
+        `Failed to start device code flow: ${error.response?.data?.error_description || error.message}`
+      );
+    }
+    throw error;
+  }
+}
+async function pollDeviceCode(config, deviceCode) {
+  const tokenUrl = `https://${config.domain}/oauth/token`;
+  try {
+    const response = await axios.post(
+      tokenUrl,
+      new URLSearchParams({
+        grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+        device_code: deviceCode,
+        client_id: config.clientId
+      }).toString(),
+      {
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded"
+        }
+      }
+    );
+    logger2.info("[Auth] Authorization successful");
+    return {
+      status: "authorized",
+      accessToken: response.data.access_token,
+      tokenType: response.data.token_type,
+      expiresIn: response.data.expires_in
+    };
+  } catch (error) {
+    if (error instanceof AxiosError && error.response) {
+      const data = error.response.data;
+      const errorCode = data.error;
+      if (errorCode === "authorization_pending") {
+        return {
+          status: "authorization_pending",
+          error: errorCode,
+          errorDescription: data.error_description || "User has not yet authorized"
+        };
+      }
+      if (errorCode === "slow_down") {
+        return {
+          status: "slow_down",
+          error: errorCode,
+          errorDescription: data.error_description || "Too many requests, slow down"
+        };
+      }
+      if (errorCode === "expired_token") {
+        return {
+          status: "expired_token",
+          error: errorCode,
+          errorDescription: data.error_description || "Device code expired, please restart flow"
+        };
+      }
+      if (errorCode === "access_denied") {
+        return {
+          status: "access_denied",
+          error: errorCode,
+          errorDescription: data.error_description || "User denied access"
+        };
+      }
+      logger2.error("[Auth] Unexpected error during poll", {
+        status: error.response.status,
+        error: errorCode,
+        description: data.error_description
+      });
+      throw new Error(
+        `Device code poll failed: ${data.error_description || data.error || "Unknown error"}`
+      );
+    }
+    throw error;
+  }
+}
+async function createApiKeyWithToken(accessToken, keyName, expiry = "90d") {
+  const config = getConfig();
+  const apiKeyUrl = `${config.qa.promptServiceBaseUrl}/v1/protected/api-keys`;
+  try {
+    logger2.info("[Auth] Creating API key", {
+      keyName,
+      expiry
+    });
+    const response = await axios.post(
+      apiKeyUrl,
+      {
+        name: keyName || "MCP Auto-Generated",
+        expiry
+      },
+      {
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          "Content-Type": "application/json"
+        }
+      }
+    );
+    logger2.info("[Auth] API key created successfully", {
+      keyId: response.data.id
+    });
+    return response.data;
+  } catch (error) {
+    if (error instanceof AxiosError) {
+      logger2.error("[Auth] Failed to create API key", {
+        status: error.response?.status,
+        data: error.response?.data
+      });
+      throw new Error(
+        `Failed to create API key: ${error.response?.data?.message || error.message}`
+      );
+    }
+    throw error;
+  }
+}
+async function performLogin(keyName, keyExpiry = "90d", timeoutMs = 12e4) {
+  const config = getConfig();
+  try {
+    const deviceCodeResponse = await startDeviceCodeFlow(config.auth0);
+    const startTime = Date.now();
+    const interval = deviceCodeResponse.interval * 1e3;
+    let currentInterval = interval;
+    while (Date.now() - startTime < timeoutMs) {
+      await new Promise((resolve2) => setTimeout(resolve2, currentInterval));
+      const pollResult = await pollDeviceCode(config.auth0, deviceCodeResponse.deviceCode);
+      if (pollResult.status === "authorized" && pollResult.accessToken) {
+        const expiresAt = new Date(
+          Date.now() + (pollResult.expiresIn || 86400) * 1e3
+        ).toISOString();
+        const apiKeyResult = await createApiKeyWithToken(
+          pollResult.accessToken,
+          keyName,
+          keyExpiry
+        );
+        const credentials = {
+          accessToken: pollResult.accessToken,
+          expiresAt,
+          apiKey: apiKeyResult.key,
+          apiKeyId: apiKeyResult.id
+        };
+        saveCredentials(credentials);
+        return {
+          success: true,
+          deviceCodeResponse,
+          credentials
+        };
+      }
+      if (pollResult.status === "slow_down") {
+        currentInterval = Math.min(currentInterval + 1e3, 15e3);
+        continue;
+      }
+      if (pollResult.status === "expired_token") {
+        return {
+          success: false,
+          error: "Device code expired. Please try again."
+        };
+      }
+      if (pollResult.status === "access_denied") {
+        return {
+          success: false,
+          error: "Access denied. User did not authorize the request."
+        };
+      }
+    }
+    return {
+      success: false,
+      deviceCodeResponse,
+      error: "Timeout waiting for user authorization"
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function performLogout() {
+  deleteCredentials();
+  logger2.info("[Auth] Logged out successfully");
+}
+function getCallerCredentials() {
+  const credentials = getValidCredentials();
+  if (!credentials) {
+    return {};
+  }
+  if (credentials.apiKey) {
+    return { apiKey: credentials.apiKey };
+  }
+  return { bearerToken: credentials.accessToken };
+}
+function toolRequiresAuth(toolName) {
+  const noAuthTools = [
+    // Auth tools
+    "muggle_auth_status",
+    "muggle_auth_login",
+    "muggle_auth_poll",
+    "muggle_auth_logout",
+    // Local project tools (no cloud)
+    "muggle_project_create",
+    "muggle_project_list",
+    "muggle_project_get",
+    "muggle_project_update",
+    "muggle_project_delete",
+    "muggle_use_case_save",
+    "muggle_use_case_list",
+    "muggle_use_case_get",
+    "muggle_use_case_update",
+    "muggle_use_case_delete",
+    "muggle_test_case_save",
+    "muggle_test_case_list",
+    "muggle_test_case_get",
+    "muggle_test_case_update",
+    "muggle_test_case_delete",
+    "muggle_test_script_save",
+    "muggle_test_script_list",
+    "muggle_test_script_get",
+    "muggle_test_script_delete",
+    "muggle_execute_test_generation",
+    "muggle_execute_replay",
+    "muggle_cancel_execution",
+    "muggle_check_status",
+    "muggle_list_sessions",
+    "muggle_cleanup_sessions",
+    "muggle_get_page_state",
+    "muggle_run_test",
+    "muggle_explore_page",
+    "muggle_execute_action",
+    "muggle_get_screenshot",
+    "muggle_run_result_list",
+    "muggle_run_result_get",
+    "muggle_secret_create",
+    "muggle_secret_list",
+    "muggle_secret_get",
+    "muggle_secret_update",
+    "muggle_secret_delete",
+    "muggle_workflow_file_create",
+    "muggle_workflow_file_list",
+    "muggle_workflow_file_list_available",
+    "muggle_workflow_file_get",
+    "muggle_workflow_file_update",
+    "muggle_workflow_file_delete"
+  ];
+  return !noAuthTools.includes(toolName);
+}
+
+// src/server/mcp-server.ts
+var registeredTools = [];
+function registerTools(tools) {
+  registeredTools = [...registeredTools, ...tools];
+}
+function getAllTools() {
+  return registeredTools;
+}
+function clearTools() {
+  registeredTools = [];
+}
+function zodToJsonSchema(schema) {
+  try {
+    const zodSchema = schema;
+    if (zodSchema._def) {
+      return convertZodDef(zodSchema);
+    }
+  } catch {
+  }
+  return {
+    type: "object",
+    properties: {},
+    additionalProperties: true
+  };
+}
+function convertZodDef(schema) {
+  const zodSchema = schema;
+  if (!zodSchema._def) {
+    return { type: "object" };
+  }
+  const def = zodSchema._def;
+  const typeName = def.typeName;
+  switch (typeName) {
+    case "ZodObject": {
+      const shape = def.shape ? def.shape() : zodSchema.shape || {};
+      const properties = {};
+      const required = [];
+      for (const [key, value] of Object.entries(shape)) {
+        properties[key] = convertZodDef(value);
+        const valueDef = value._def;
+        if (valueDef?.typeName !== "ZodOptional") {
+          required.push(key);
+        }
+      }
+      const result = {
+        type: "object",
+        properties
+      };
+      if (required.length > 0) {
+        result.required = required;
+      }
+      return result;
+    }
+    case "ZodString": {
+      const result = { type: "string" };
+      if (def.description) result.description = def.description;
+      if (def.checks) {
+        for (const check of def.checks) {
+          if (check.kind === "min") result.minLength = check.value;
+          if (check.kind === "max") result.maxLength = check.value;
+          if (check.kind === "url") result.format = "uri";
+          if (check.kind === "email") result.format = "email";
+        }
+      }
+      return result;
+    }
+    case "ZodNumber": {
+      const result = { type: "number" };
+      if (def.description) result.description = def.description;
+      if (def.checks) {
+        for (const check of def.checks) {
+          if (check.kind === "int") result.type = "integer";
+          if (check.kind === "min") result.minimum = check.value;
+          if (check.kind === "max") result.maximum = check.value;
+        }
+      }
+      return result;
+    }
+    case "ZodBoolean": {
+      const result = { type: "boolean" };
+      if (def.description) result.description = def.description;
+      return result;
+    }
+    case "ZodArray": {
+      const result = {
+        type: "array",
+        items: def.innerType ? convertZodDef(def.innerType) : {}
+      };
+      if (def.description) result.description = def.description;
+      return result;
+    }
+    case "ZodEnum": {
+      const result = {
+        type: "string",
+        enum: def.values || []
+      };
+      if (def.description) result.description = def.description;
+      return result;
+    }
+    case "ZodOptional": {
+      const inner = def.innerType ? convertZodDef(def.innerType) : {};
+      if (def.description) inner.description = def.description;
+      return inner;
+    }
+    case "ZodUnion": {
+      const options = def.options || [];
+      return {
+        oneOf: options.map((opt) => convertZodDef(opt))
+      };
+    }
+    default:
+      return { type: "object" };
+  }
+}
+async function handleJitAuth(toolName, correlationId) {
+  const childLogger = createChildLogger(correlationId);
+  if (!toolRequiresAuth(toolName)) {
+    return { credentials: {}, authTriggered: false };
+  }
+  const credentials = getCallerCredentials();
+  if (credentials.apiKey || credentials.bearerToken) {
+    return { credentials, authTriggered: false };
+  }
+  childLogger.info("No credentials found, triggering JIT auth", { tool: toolName });
+  return { credentials: {}, authTriggered: false };
+}
+function createUnifiedMcpServer(options) {
+  const logger5 = getLogger();
+  const config = getConfig();
+  const server = new Server(
+    {
+      name: config.serverName,
+      version: config.serverVersion
+    },
+    {
+      capabilities: {
+        tools: {},
+        resources: {}
+      }
+    }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, () => {
+    const tools = getAllTools();
+    logger5.debug("Listing tools", { count: tools.length });
+    const toolDefinitions = tools.map((tool) => {
+      const jsonSchema = zodToJsonSchema(tool.inputSchema);
+      return {
+        name: tool.name,
+        description: tool.description,
+        inputSchema: jsonSchema
+      };
+    });
+    return { tools: toolDefinitions };
+  });
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const correlationId = v4();
+    const childLogger = createChildLogger(correlationId);
+    const toolName = request.params.name;
+    const toolInput = request.params.arguments || {};
+    childLogger.info("Tool call received", {
+      tool: toolName,
+      hasArguments: Object.keys(toolInput).length > 0
+    });
+    try {
+      const tool = getAllTools().find((t) => t.name === toolName);
+      if (!tool) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                error: "NOT_FOUND",
+                message: `Unknown tool: ${toolName}`
+              })
+            }
+          ],
+          isError: true
+        };
+      }
+      const { authTriggered } = await handleJitAuth(toolName, correlationId);
+      if (authTriggered) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                message: "Authentication required. Please complete login in your browser."
+              })
+            }
+          ]
+        };
+      }
+      const startTime = Date.now();
+      const result = await tool.execute({
+        input: toolInput,
+        correlationId
+      });
+      const latency = Date.now() - startTime;
+      childLogger.info("Tool call completed", {
+        tool: toolName,
+        latencyMs: latency,
+        isError: result.isError
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: result.content
+          }
+        ],
+        isError: result.isError
+      };
+    } catch (error) {
+      if (error instanceof ZodError) {
+        childLogger.warn("Tool call failed with validation error", {
+          tool: toolName,
+          errors: error.errors
+        });
+        const issueMessages = error.errors.slice(0, 3).map((issue) => {
+          const path7 = issue.path.join(".");
+          return path7 ? `'${path7}': ${issue.message}` : issue.message;
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                error: "INVALID_ARGUMENT",
+                message: `Invalid input: ${issueMessages.join("; ")}`
+              })
+            }
+          ],
+          isError: true
+        };
+      }
+      childLogger.error("Tool call failed with error", {
+        tool: toolName,
+        error: String(error)
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              error: "INTERNAL_ERROR",
+              message: error instanceof Error ? error.message : "An unexpected error occurred"
+            })
+          }
+        ],
+        isError: true
+      };
+    }
+  });
+  server.setRequestHandler(ListResourcesRequestSchema, () => {
+    logger5.debug("Listing resources");
+    return { resources: [] };
+  });
+  server.setRequestHandler(ReadResourceRequestSchema, (request) => {
+    const uri = request.params.uri;
+    logger5.debug("Reading resource", { uri });
+    return {
+      contents: [
+        {
+          uri,
+          mimeType: "text/plain",
+          text: `Resource not found: ${uri}`
+        }
+      ]
+    };
+  });
+  logger5.info("Unified MCP server configured", {
+    tools: getAllTools().length,
+    enableQaTools: options.enableQaTools,
+    enableLocalTools: options.enableLocalTools
+  });
+  return server;
+}
+
+// src/server/index.ts
+var server_exports = {};
+__export(server_exports, {
+  clearTools: () => clearTools,
+  createUnifiedMcpServer: () => createUnifiedMcpServer,
+  getAllTools: () => getAllTools,
+  registerTools: () => registerTools,
+  startStdioServer: () => startStdioServer
+});
+var logger3 = getLogger();
+async function startStdioServer(server) {
+  logger3.info("Starting stdio server transport");
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  logger3.info("Stdio server connected");
+  const shutdown = (signal) => {
+    logger3.info(`Received ${signal}, shutting down...`);
+    process.exit(0);
+  };
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+  process.on("SIGINT", () => shutdown("SIGINT"));
+}
+
+// src/qa/index.ts
+var qa_exports = {};
+__export(qa_exports, {
+  ApiKeyCreateInputSchema: () => ApiKeyCreateInputSchema,
+  ApiKeyGetInputSchema: () => ApiKeyGetInputSchema,
+  ApiKeyListInputSchema: () => ApiKeyListInputSchema,
+  ApiKeyRevokeInputSchema: () => ApiKeyRevokeInputSchema,
+  AuthLoginInputSchema: () => AuthLoginInputSchema,
+  AuthPollInputSchema: () => AuthPollInputSchema,
+  EmptyInputSchema: () => EmptyInputSchema,
+  GatewayError: () => GatewayError,
+  IdSchema: () => IdSchema,
+  McpErrorCode: () => McpErrorCode,
+  PaginationInputSchema: () => PaginationInputSchema,
+  PrdFileDeleteInputSchema: () => PrdFileDeleteInputSchema,
+  PrdFileListInputSchema: () => PrdFileListInputSchema,
+  PrdFileProcessLatestRunInputSchema: () => PrdFileProcessLatestRunInputSchema,
+  PrdFileProcessStartInputSchema: () => PrdFileProcessStartInputSchema,
+  PrdFileUploadInputSchema: () => PrdFileUploadInputSchema,
+  ProjectCreateInputSchema: () => ProjectCreateInputSchema,
+  ProjectDeleteInputSchema: () => ProjectDeleteInputSchema,
+  ProjectGetInputSchema: () => ProjectGetInputSchema,
+  ProjectListInputSchema: () => ProjectListInputSchema,
+  ProjectTestResultsSummaryInputSchema: () => ProjectTestResultsSummaryInputSchema,
+  ProjectTestRunsSummaryInputSchema: () => ProjectTestRunsSummaryInputSchema,
+  ProjectTestScriptsSummaryInputSchema: () => ProjectTestScriptsSummaryInputSchema,
+  ProjectUpdateInputSchema: () => ProjectUpdateInputSchema,
+  PromptServiceClient: () => PromptServiceClient,
+  RecommendCicdSetupInputSchema: () => RecommendCicdSetupInputSchema,
+  RecommendScheduleInputSchema: () => RecommendScheduleInputSchema,
+  ReportCostQueryInputSchema: () => ReportCostQueryInputSchema,
+  ReportFinalGenerateInputSchema: () => ReportFinalGenerateInputSchema,
+  ReportPreferencesUpsertInputSchema: () => ReportPreferencesUpsertInputSchema,
+  ReportStatsSummaryInputSchema: () => ReportStatsSummaryInputSchema,
+  SecretCreateInputSchema: () => SecretCreateInputSchema,
+  SecretDeleteInputSchema: () => SecretDeleteInputSchema,
+  SecretGetInputSchema: () => SecretGetInputSchema,
+  SecretListInputSchema: () => SecretListInputSchema,
+  SecretUpdateInputSchema: () => SecretUpdateInputSchema,
+  TestCaseCreateInputSchema: () => TestCaseCreateInputSchema,
+  TestCaseGenerateFromPromptInputSchema: () => TestCaseGenerateFromPromptInputSchema,
+  TestCaseGetInputSchema: () => TestCaseGetInputSchema,
+  TestCaseListByUseCaseInputSchema: () => TestCaseListByUseCaseInputSchema,
+  TestCaseListInputSchema: () => TestCaseListInputSchema,
+  TestScriptGetInputSchema: () => TestScriptGetInputSchema,
+  TestScriptListInputSchema: () => TestScriptListInputSchema,
+  TestScriptListPaginatedInputSchema: () => TestScriptListPaginatedInputSchema,
+  UseCaseCandidatesApproveInputSchema: () => UseCaseCandidatesApproveInputSchema,
+  UseCaseCreateFromPromptsInputSchema: () => UseCaseCreateFromPromptsInputSchema,
+  UseCaseDiscoveryMemoryGetInputSchema: () => UseCaseDiscoveryMemoryGetInputSchema,
+  UseCaseGetInputSchema: () => UseCaseGetInputSchema,
+  UseCaseListInputSchema: () => UseCaseListInputSchema,
+  UseCasePromptPreviewInputSchema: () => UseCasePromptPreviewInputSchema,
+  UseCaseUpdateFromPromptInputSchema: () => UseCaseUpdateFromPromptInputSchema,
+  WalletAutoTopUpSetPaymentMethodInputSchema: () => WalletAutoTopUpSetPaymentMethodInputSchema,
+  WalletAutoTopUpUpdateInputSchema: () => WalletAutoTopUpUpdateInputSchema,
+  WalletPaymentMethodCreateSetupSessionInputSchema: () => WalletPaymentMethodCreateSetupSessionInputSchema,
+  WalletPaymentMethodListInputSchema: () => WalletPaymentMethodListInputSchema,
+  WalletTopUpInputSchema: () => WalletTopUpInputSchema,
+  WorkflowCancelRunInputSchema: () => WorkflowCancelRunInputSchema,
+  WorkflowCancelRuntimeInputSchema: () => WorkflowCancelRuntimeInputSchema,
+  WorkflowGetLatestRunInputSchema: () => WorkflowGetLatestRunInputSchema,
+  WorkflowGetLatestScriptGenByTestCaseInputSchema: () => WorkflowGetLatestScriptGenByTestCaseInputSchema,
+  WorkflowGetReplayBulkBatchSummaryInputSchema: () => WorkflowGetReplayBulkBatchSummaryInputSchema,
+  WorkflowListRuntimesInputSchema: () => WorkflowListRuntimesInputSchema,
+  WorkflowParamsSchema: () => WorkflowParamsSchema,
+  WorkflowStartTestCaseDetectionInputSchema: () => WorkflowStartTestCaseDetectionInputSchema,
+  WorkflowStartTestScriptGenerationInputSchema: () => WorkflowStartTestScriptGenerationInputSchema,
+  WorkflowStartTestScriptReplayBulkInputSchema: () => WorkflowStartTestScriptReplayBulkInputSchema,
+  WorkflowStartTestScriptReplayInputSchema: () => WorkflowStartTestScriptReplayInputSchema,
+  WorkflowStartWebsiteScanInputSchema: () => WorkflowStartWebsiteScanInputSchema,
+  allQaToolDefinitions: () => allQaToolDefinitions,
+  executeQaTool: () => executeQaTool,
+  getPromptServiceClient: () => getPromptServiceClient,
+  getQaToolByName: () => getQaToolByName,
+  getQaTools: () => getQaTools
+});
+var PaginationInputSchema = z.object({
+  page: z.number().int().positive().optional().describe("Page number (1-based)"),
+  pageSize: z.number().int().positive().max(100).optional().describe("Number of items per page")
+});
+var IdSchema = z.string().min(1).describe("Unique identifier");
+var WorkflowParamsSchema = z.record(z.unknown()).optional().describe("Optional workflow parameters for memory configuration overrides");
+var ProjectCreateInputSchema = z.object({
+  projectName: z.string().min(1).max(255).describe("Name of the project"),
+  description: z.string().min(1).describe("Project description"),
+  url: z.string().url().describe("Target website URL to test")
+});
+var ProjectGetInputSchema = z.object({
+  projectId: IdSchema.describe("Project ID to retrieve")
+});
+var ProjectDeleteInputSchema = z.object({
+  projectId: IdSchema.describe("Project ID to delete")
+});
+var ProjectUpdateInputSchema = z.object({
+  projectId: IdSchema.describe("Project ID to update"),
+  projectName: z.string().min(1).max(255).optional().describe("New project name"),
+  description: z.string().optional().describe("Updated description"),
+  url: z.string().url().optional().describe("Updated target URL")
+});
+var ProjectListInputSchema = PaginationInputSchema.extend({});
+var PrdFileUploadInputSchema = z.object({
+  projectId: IdSchema.describe("Project ID to associate the PRD file with"),
+  fileName: z.string().min(1).describe("Name of the file"),
+  contentBase64: z.string().min(1).describe("Base64-encoded file content"),
+  contentType: z.string().optional().describe("MIME type of the file")
+});
+var PrdFileListInputSchema = z.object({
+  projectId: IdSchema.describe("Project ID to list PRD files for")
+});
+var PrdFileDeleteInputSchema = z.object({
+  projectId: IdSchema.describe("Project ID"),
+  prdFileId: IdSchema.describe("PRD file ID to delete")
+});
+var PrdFileProcessStartInputSchema = z.object({
+  projectId: IdSchema.describe("Project ID to process PRD files for"),
+  name: z.string().min(1).describe("Workflow name"),
+  description: z.string().min(1).describe("Description of the PRD processing workflow"),
+  prdFilePath: z.string().min(1).describe("Storage path of the uploaded PRD file (from upload response)"),
+  originalFileName: z.string().min(1).describe("Original file name of the PRD document"),
+  url: z.string().url().describe("Target website URL for context"),
+  contentChecksum: z.string().min(1).describe("SHA-256 checksum of the PRD file content (from upload response)"),
+  fileSize: z.number().int().min(0).describe("Size of the PRD file in bytes (from upload response)")
+});
+var PrdFileProcessLatestRunInputSchema = z.object({
+  workflowRuntimeId: IdSchema.describe("PRD processing workflow runtime ID")
+});
+var SecretListInputSchema = z.object({
+  projectId: IdSchema.describe("Project ID to list secrets for")
+});
+var SecretCreateInputSchema = z.object({
+  projectId: IdSchema.describe("Project ID to create the secret for"),
+  name: z.string().min(1).describe("Secret name/key"),
+  value: z.string().min(1).describe("Secret value"),
+  description: z.string().min(1).describe("Human-readable description for selection guidance"),
+  source: z.enum(["user", "agent"]).optional().describe("Source of the secret: 'user' for user-provided credentials, 'agent' for agent-generated credentials")
+});
+var SecretGetInputSchema = z.object({
+  secretId: IdSchema.describe("Secret ID to retrieve")
+});
+var SecretUpdateInputSchema = z.object({
+  secretId: IdSchema.describe("Secret ID to update"),
+  name: z.string().min(1).optional().describe("Updated secret name"),
+  value: z.string().min(1).optional().describe("Updated secret value"),
+  description: z.string().optional().describe("Updated description")
+});
+var SecretDeleteInputSchema = z.object({
+  secretId: IdSchema.describe("Secret ID to delete")
+});
+var UseCaseDiscoveryMemoryGetInputSchema = z.object({
+  projectId: IdSchema.describe("Project ID to get use case discovery memory for")
+});
+var UseCaseCandidatesApproveInputSchema = z.object({
+  projectId: IdSchema.describe("Project ID"),
+  approvedCandidateIds: z.array(IdSchema).min(1).describe("IDs of candidates to approve/graduate")
+});
+var UseCaseListInputSchema = z.object({
+  projectId: IdSchema.describe("Project ID to list use cases for")
+}).merge(PaginationInputSchema);
+var UseCaseGetInputSchema = z.object({
+  useCaseId: IdSchema.describe("Use case ID to retrieve")
+});
+var UseCasePromptPreviewInputSchema = z.object({
+  projectId: IdSchema.describe("Project ID to generate use case for"),
+  instruction: z.string().min(1).describe("Natural language instruction describing the use case (e.g., 'As a logged-in user, I can add items to cart')")
+});
+var UseCaseCreateFromPromptsInputSchema = z.object({
+  projectId: IdSchema.describe("Project ID to create use cases for"),
+  prompts: z.array(z.object({
+    instruction: z.string().min(1).describe("Natural language instruction describing the use case")
+  })).min(1).describe("Array of prompts to generate use cases from")
+});
+var UseCaseUpdateFromPromptInputSchema = z.object({
+  projectId: IdSchema.describe("Project ID"),
+  useCaseId: IdSchema.describe("Use case ID to update"),
+  instruction: z.string().min(1).describe("Natural language instruction to regenerate the use case from")
+});
+var TestCaseListInputSchema = z.object({
+  projectId: IdSchema.describe("Project ID to list test cases for")
+}).merge(PaginationInputSchema);
+var TestCaseGetInputSchema = z.object({
+  testCaseId: IdSchema.describe("Test case ID to retrieve")
+});
+var TestCaseListByUseCaseInputSchema = z.object({
+  useCaseId: IdSchema.describe("Use case ID to list test cases for")
+});
+var TestCaseGenerateFromPromptInputSchema = z.object({
+  projectId: IdSchema.describe("Project ID"),
+  useCaseId: IdSchema.describe("Use case ID to generate test cases for"),
+  instruction: z.string().min(1).describe("Natural language instruction describing the test cases to generate")
+});
+var TestCaseCreateInputSchema = z.object({
+  projectId: IdSchema.describe("Project ID"),
+  useCaseId: IdSchema.describe("Use case ID to associate the test case with"),
+  title: z.string().min(1).describe("Test case title"),
+  description: z.string().min(1).describe("Detailed description of what the test case validates"),
+  goal: z.string().min(1).describe("Concise, measurable goal of the test"),
+  precondition: z.string().optional().describe("Initial state/setup required before test execution"),
+  expectedResult: z.string().min(1).describe("Expected outcome after test execution"),
+  url: z.string().url().describe("Target URL for the test case"),
+  status: z.enum(["DRAFT", "ACTIVE", "DEPRECATED", "ARCHIVED"]).optional().describe("Test case status"),
+  priority: z.enum(["HIGH", "MEDIUM", "LOW"]).optional().describe("Test case priority"),
+  tags: z.array(z.string()).optional().describe("Tags for categorization"),
+  category: z.string().optional().describe("Test case category"),
+  automated: z.boolean().optional().describe("Whether this test case is automated (default: true)")
+});
+var TestScriptListInputSchema = z.object({
+  projectId: IdSchema.describe("Project ID to list test scripts for")
+}).merge(PaginationInputSchema);
+var TestScriptGetInputSchema = z.object({
+  testScriptId: IdSchema.describe("Test script ID to retrieve")
+});
+var TestScriptListPaginatedInputSchema = z.object({
+  projectId: IdSchema.describe("Project ID to list test scripts for")
+}).merge(PaginationInputSchema);
+var WorkflowStartWebsiteScanInputSchema = z.object({
+  projectId: IdSchema.describe("Project ID to scan"),
+  url: z.string().url().describe("Website URL to scan"),
+  description: z.string().min(1).describe("Description of what to scan/discover"),
+  archiveUnapproved: z.boolean().optional().describe("Whether to archive unapproved candidates before scanning"),
+  workflowParams: WorkflowParamsSchema
+});
+var WorkflowListRuntimesInputSchema = z.object({
+  projectId: IdSchema.optional().describe("Filter by project ID")
+});
+var WorkflowGetLatestRunInputSchema = z.object({
+  workflowRuntimeId: IdSchema.describe("Workflow runtime ID")
+});
+var WorkflowStartTestCaseDetectionInputSchema = z.object({
+  projectId: IdSchema.describe("Project ID"),
+  useCaseId: IdSchema.describe("Use case ID to detect test cases for"),
+  name: z.string().min(1).describe("Workflow name"),
+  description: z.string().min(1).describe("Workflow description"),
+  url: z.string().url().describe("Target website URL"),
+  workflowParams: WorkflowParamsSchema
+});
+var WorkflowStartTestScriptGenerationInputSchema = z.object({
+  projectId: IdSchema.describe("Project ID"),
+  useCaseId: IdSchema.describe("Use case ID"),
+  testCaseId: IdSchema.describe("Test case ID"),
+  name: z.string().min(1).describe("Workflow name"),
+  url: z.string().url().describe("Target website URL"),
+  goal: z.string().min(1).describe("Test goal"),
+  precondition: z.string().min(1).describe("Preconditions"),
+  instructions: z.string().min(1).describe("Step-by-step instructions"),
+  expectedResult: z.string().min(1).describe("Expected result"),
+  workflowParams: WorkflowParamsSchema
+});
+var WorkflowGetLatestScriptGenByTestCaseInputSchema = z.object({
+  testCaseId: IdSchema.describe("Test case ID")
+});
+var WorkflowStartTestScriptReplayInputSchema = z.object({
+  projectId: IdSchema.describe("Project ID"),
+  useCaseId: IdSchema.describe("Use case ID"),
+  testCaseId: IdSchema.describe("Test case ID"),
+  testScriptId: IdSchema.describe("Test script ID to replay"),
+  name: z.string().min(1).describe("Workflow name"),
+  workflowParams: WorkflowParamsSchema
+});
+var WorkflowStartTestScriptReplayBulkInputSchema = z.object({
+  projectId: IdSchema.describe("Project ID"),
+  name: z.string().min(1).describe("Workflow name"),
+  intervalSec: z.number().int().describe("Interval in seconds (-1 for one-time / on-demand)"),
+  useCaseId: IdSchema.optional().describe("Optional: only replay test cases under this use case"),
+  namePrefix: z.string().optional().describe("Optional: prefix for generated workflow names"),
+  limit: z.number().int().optional().describe("Optional: limit number of test cases to replay"),
+  testCaseIds: z.array(IdSchema).optional().describe("Optional: targeted test cases to replay"),
+  repeatPerTestCase: z.number().int().optional().describe("Optional: repeat count per test case"),
+  workflowParams: WorkflowParamsSchema
+});
+var WorkflowGetReplayBulkBatchSummaryInputSchema = z.object({
+  runBatchId: IdSchema.describe("Run batch ID")
+});
+var WorkflowCancelRunInputSchema = z.object({
+  workflowRunId: IdSchema.describe("Workflow run ID to cancel")
+});
+var WorkflowCancelRuntimeInputSchema = z.object({
+  workflowRuntimeId: IdSchema.describe("Workflow runtime ID to cancel")
+});
+var ProjectTestResultsSummaryInputSchema = z.object({
+  projectId: IdSchema.describe("Project ID to get test results summary for")
+});
+var ProjectTestScriptsSummaryInputSchema = z.object({
+  projectId: IdSchema.describe("Project ID to get test scripts summary for")
+});
+var ProjectTestRunsSummaryInputSchema = z.object({
+  projectId: IdSchema.describe("Project ID to get test runs summary for")
+});
+var ReportStatsSummaryInputSchema = z.object({
+  projectId: IdSchema.describe("Project ID to get report stats for")
+});
+var ReportCostQueryInputSchema = z.object({
+  projectId: IdSchema.describe("Project ID"),
+  startDateKey: z.string().optional().describe("Start date key (YYYYMMDD)"),
+  endDateKey: z.string().optional().describe("End date key (YYYYMMDD)"),
+  filterType: z.string().optional().describe("Filter type for cost breakdown"),
+  filterIds: z.array(z.unknown()).optional().describe("Filter IDs")
+});
+var ReportPreferencesUpsertInputSchema = z.object({
+  projectId: IdSchema.describe("Project ID"),
+  channels: z.array(z.unknown()).describe("Delivery channels to enable"),
+  emails: z.array(z.unknown()).optional().describe("Email addresses for delivery"),
+  phones: z.array(z.unknown()).optional().describe("Phone numbers for SMS delivery"),
+  webhookUrl: z.string().url().optional().describe("Webhook URL for delivery"),
+  defaultExportFormat: z.string().optional().describe("Default export format (pdf, html, etc.)")
+});
+var ReportFinalGenerateInputSchema = z.object({
+  projectId: IdSchema.describe("Project ID to generate report for"),
+  exportFormat: z.enum(["pdf", "html", "markdown"]).describe("Export format for the report")
+});
+var WalletTopUpInputSchema = z.object({
+  packageId: IdSchema.describe("Token package ID to purchase"),
+  checkoutSuccessCallback: z.string().url().describe("URL to redirect to when checkout succeeds"),
+  checkoutCancelCallback: z.string().url().describe("URL to redirect to when checkout is canceled")
+});
+var WalletPaymentMethodCreateSetupSessionInputSchema = z.object({
+  checkoutSuccessCallback: z.string().url().describe("URL to redirect to when payment method setup succeeds"),
+  checkoutCancelCallback: z.string().url().describe("URL to redirect to when payment method setup is canceled")
+});
+var WalletAutoTopUpSetPaymentMethodInputSchema = z.object({
+  paymentMethodId: IdSchema.describe("Saved Stripe payment method ID (e.g., pm_xxx)")
+});
+var WalletPaymentMethodListInputSchema = z.object({});
+var WalletAutoTopUpUpdateInputSchema = z.object({
+  enabled: z.boolean().describe("Whether auto top-up is enabled"),
+  topUpTriggerTokenThreshold: z.number().int().min(0).describe("Token balance threshold to trigger auto top-up"),
+  packageId: IdSchema.describe("Token package ID to purchase when auto top-up triggers")
+});
+var RecommendScheduleInputSchema = z.object({
+  projectId: IdSchema.optional().describe("Project ID for context"),
+  testFrequency: z.enum(["daily", "weekly", "onDemand"]).optional().describe("Desired test frequency"),
+  timezone: z.string().optional().describe("Timezone for scheduling")
+});
+var RecommendCicdSetupInputSchema = z.object({
+  projectId: IdSchema.optional().describe("Project ID for context"),
+  repositoryProvider: z.enum(["github", "azureDevOps", "gitlab", "other"]).optional().describe("Git repository provider"),
+  cadence: z.enum(["onPullRequest", "nightly", "onDemand"]).optional().describe("CI/CD trigger cadence")
+});
+var ApiKeyCreateInputSchema = z.object({
+  name: z.string().optional().describe("Name for the API key (helps identify the key later)"),
+  expiry: z.enum(["30d", "90d", "1y", "never"]).optional().describe("Key expiry period (default: 90d)")
+});
+var ApiKeyListInputSchema = z.object({});
+var ApiKeyGetInputSchema = z.object({
+  apiKeyId: IdSchema.describe("ID of the API key to retrieve")
+});
+var ApiKeyRevokeInputSchema = z.object({
+  apiKeyId: IdSchema.describe("ID of the API key to revoke")
+});
+var AuthLoginInputSchema = z.object({
+  waitForCompletion: z.boolean().optional().describe("Whether to wait for browser login completion before returning. Default: true"),
+  timeoutMs: z.number().int().positive().min(1e3).max(9e5).optional().describe("Maximum time to wait for login completion in milliseconds. Default: 120000")
+});
+var AuthPollInputSchema = z.object({
+  deviceCode: z.string().optional().describe("Device code from the login response. Optional if a login was recently started.")
+});
+var EmptyInputSchema = z.object({});
+
+// src/qa/types.ts
+var McpErrorCode = /* @__PURE__ */ ((McpErrorCode2) => {
+  McpErrorCode2["UNAUTHORIZED"] = "UNAUTHORIZED";
+  McpErrorCode2["FORBIDDEN"] = "FORBIDDEN";
+  McpErrorCode2["NOT_FOUND"] = "NOT_FOUND";
+  McpErrorCode2["INVALID_ARGUMENT"] = "INVALID_ARGUMENT";
+  McpErrorCode2["UPSTREAM_ERROR"] = "UPSTREAM_ERROR";
+  McpErrorCode2["INTERNAL_ERROR"] = "INTERNAL_ERROR";
+  return McpErrorCode2;
+})(McpErrorCode || {});
+var GatewayError = class extends Error {
+  /** MCP error code. */
+  code;
+  /** HTTP status code (if applicable). */
+  statusCode;
+  /** Additional error details. */
+  details;
+  constructor(params) {
+    super(params.message);
+    this.name = "GatewayError";
+    this.code = params.code;
+    this.statusCode = params.statusCode;
+    this.details = params.details;
+  }
+};
+var ALLOWED_UPSTREAM_PREFIXES = [
+  "/v1/protected/muggle-test/",
+  "/v1/protected/wallet/",
+  "/v1/protected/api-keys"
+];
+var PromptServiceClient = class {
+  httpClient;
+  baseUrl;
+  requestTimeoutMs;
+  constructor() {
+    const config = getConfig();
+    this.baseUrl = config.qa.promptServiceBaseUrl;
+    this.requestTimeoutMs = config.qa.requestTimeoutMs;
+    this.httpClient = axios.create({
+      baseURL: this.baseUrl,
+      timeout: this.requestTimeoutMs,
+      validateStatus: () => true
+    });
+  }
+  /**
+   * Validate that the upstream path is within the allowed prefix.
+   * @param path - Path to validate.
+   * @throws GatewayError if path is not allowed.
+   */
+  validatePath(path7) {
+    const isAllowed = ALLOWED_UPSTREAM_PREFIXES.some((prefix) => path7.startsWith(prefix));
+    if (!isAllowed) {
+      const logger5 = getLogger();
+      logger5.error("Path not in allowlist", {
+        path: path7,
+        allowedPrefixes: ALLOWED_UPSTREAM_PREFIXES
+      });
+      throw new GatewayError({
+        code: "FORBIDDEN" /* FORBIDDEN */,
+        message: `Path '${path7}' is not allowed`
+      });
+    }
+  }
+  /**
+   * Build headers for upstream request with credential forwarding.
+   * @param credentials - Caller credentials to forward.
+   * @param correlationId - Request correlation ID.
+   * @returns Headers object.
+   */
+  buildHeaders(credentials, correlationId) {
+    const headers = {
+      "X-Correlation-Id": correlationId
+    };
+    if (credentials.bearerToken) {
+      headers["Authorization"] = credentials.bearerToken.startsWith("Bearer ") ? credentials.bearerToken : `Bearer ${credentials.bearerToken}`;
+    }
+    if (credentials.apiKey) {
+      headers["x-api-key"] = credentials.apiKey;
+    }
+    return headers;
+  }
+  /**
+   * Build query string from parameters.
+   * @param params - Query parameters.
+   * @returns Query string (without leading '?').
+   */
+  buildQueryString(params) {
+    if (!params) {
+      return "";
+    }
+    const entries = Object.entries(params).filter(([, value]) => value !== void 0).map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+    return entries.length > 0 ? `?${entries.join("&")}` : "";
+  }
+  /**
+   * Map HTTP status code to MCP error code.
+   * @param statusCode - HTTP status code.
+   * @returns MCP error code.
+   */
+  mapStatusToErrorCode(statusCode) {
+    if (statusCode === 401) {
+      return "UNAUTHORIZED" /* UNAUTHORIZED */;
+    }
+    if (statusCode === 403) {
+      return "FORBIDDEN" /* FORBIDDEN */;
+    }
+    if (statusCode === 404) {
+      return "NOT_FOUND" /* NOT_FOUND */;
+    }
+    if (statusCode >= 400 && statusCode < 500) {
+      return "INVALID_ARGUMENT" /* INVALID_ARGUMENT */;
+    }
+    return "UPSTREAM_ERROR" /* UPSTREAM_ERROR */;
+  }
+  /**
+   * Format upstream error response into a user-friendly message.
+   * @param statusCode - HTTP status code.
+   * @param data - Response data from upstream.
+   * @returns User-friendly error message.
+   */
+  formatUpstreamErrorMessage(statusCode, data) {
+    const responseData = data;
+    const rawMessage = responseData?.message || responseData?.error || responseData?.detail || responseData?.details;
+    if (rawMessage && typeof rawMessage === "string") {
+      let cleaned = rawMessage.replace(/^Error:\s*/i, "").replace(/^INVALID_ARGUMENT:\s*/i, "").replace(/^NOT_FOUND:\s*/i, "").replace(/^FORBIDDEN:\s*/i, "");
+      cleaned = cleaned.charAt(0).toUpperCase() + cleaned.slice(1);
+      return cleaned;
+    }
+    switch (statusCode) {
+      case 400:
+        return "Invalid request. Please check your input parameters.";
+      case 401:
+        return "Authentication required. Please check your credentials.";
+      case 403:
+        return "You don't have permission to perform this action.";
+      case 404:
+        return "The requested resource was not found.";
+      case 409:
+        return "A conflict occurred. The resource may already exist.";
+      case 429:
+        return "Too many requests. Please wait and try again.";
+      case 500:
+        return "The service encountered an error. Please try again later.";
+      case 502:
+      case 503:
+      case 504:
+        return "The service is temporarily unavailable. Please try again later.";
+      default:
+        return `Request failed with status ${statusCode}.`;
+    }
+  }
+  /**
+   * Execute an upstream call to prompt-service.
+   * @param call - Upstream call specification.
+   * @param credentials - Caller credentials to forward.
+   * @param correlationId - Request correlation ID.
+   * @returns Upstream response.
+   * @throws GatewayError on validation or upstream errors.
+   */
+  async execute(call, credentials, correlationId) {
+    const logger5 = getLogger();
+    if (!credentials.bearerToken && !credentials.apiKey) {
+      throw new GatewayError({
+        code: "UNAUTHORIZED" /* UNAUTHORIZED */,
+        message: "Missing authentication. Please run 'muggle-mcp login' to authenticate."
+      });
+    }
+    this.validatePath(call.path);
+    const url = call.path + this.buildQueryString(call.queryParams);
+    const headers = this.buildHeaders(credentials, correlationId);
+    const timeout = call.timeoutMs || this.requestTimeoutMs;
+    const startTime = Date.now();
+    logger5.info("Upstream request", {
+      correlationId,
+      method: call.method,
+      path: call.path,
+      hasBody: !!call.body
+    });
+    try {
+      const requestConfig = {
+        method: call.method,
+        url,
+        headers,
+        timeout
+      };
+      if (call.body && ["POST", "PUT", "PATCH"].includes(call.method)) {
+        requestConfig.data = call.body;
+        requestConfig.headers = {
+          ...headers,
+          "Content-Type": "application/json"
+        };
+      } else {
+        requestConfig.headers = {
+          ...headers,
+          "Content-Type": "application/json"
+        };
+      }
+      const response = await this.httpClient.request(requestConfig);
+      const latency = Date.now() - startTime;
+      logger5.info("Upstream response", {
+        correlationId,
+        statusCode: response.status,
+        latencyMs: latency
+      });
+      if (response.status >= 400) {
+        const errorCode = this.mapStatusToErrorCode(response.status);
+        const errorMessage = this.formatUpstreamErrorMessage(response.status, response.data);
+        throw new GatewayError({
+          code: errorCode,
+          message: errorMessage,
+          statusCode: response.status
+        });
+      }
+      const responseHeaders = {};
+      for (const [key, value] of Object.entries(response.headers)) {
+        if (typeof value === "string") {
+          responseHeaders[key.toLowerCase()] = value;
+        }
+      }
+      return {
+        statusCode: response.status,
+        data: response.data,
+        headers: responseHeaders
+      };
+    } catch (error) {
+      const latency = Date.now() - startTime;
+      if (error instanceof GatewayError) {
+        throw error;
+      }
+      if (error instanceof AxiosError) {
+        logger5.error("Upstream request failed", {
+          correlationId,
+          error: error.message,
+          code: error.code,
+          latencyMs: latency
+        });
+        if (error.code === "ECONNABORTED" || error.code === "ETIMEDOUT") {
+          throw new GatewayError({
+            code: "UPSTREAM_ERROR" /* UPSTREAM_ERROR */,
+            message: `Request timeout after ${timeout}ms`,
+            details: { upstreamPath: call.path }
+          });
+        }
+        throw new GatewayError({
+          code: "UPSTREAM_ERROR" /* UPSTREAM_ERROR */,
+          message: `Upstream connection error: ${error.message}`,
+          details: { upstreamPath: call.path }
+        });
+      }
+      logger5.error("Unknown upstream error", {
+        correlationId,
+        error: String(error),
+        latencyMs: latency
+      });
+      throw new GatewayError({
+        code: "INTERNAL_ERROR" /* INTERNAL_ERROR */,
+        message: "Internal gateway error"
+      });
+    }
+  }
+};
+var clientInstance = null;
+function getPromptServiceClient() {
+  if (!clientInstance) {
+    clientInstance = new PromptServiceClient();
+  }
+  return clientInstance;
+}
+
+// src/local-qa/types/enums.ts
+var DeviceCodePollStatus = /* @__PURE__ */ ((DeviceCodePollStatus2) => {
+  DeviceCodePollStatus2["Pending"] = "pending";
+  DeviceCodePollStatus2["Complete"] = "complete";
+  DeviceCodePollStatus2["Expired"] = "expired";
+  DeviceCodePollStatus2["Error"] = "error";
+  return DeviceCodePollStatus2;
+})(DeviceCodePollStatus || {});
+var SessionStatus = /* @__PURE__ */ ((SessionStatus2) => {
+  SessionStatus2["Running"] = "running";
+  SessionStatus2["Completed"] = "completed";
+  SessionStatus2["Failed"] = "failed";
+  return SessionStatus2;
+})(SessionStatus || {});
+var LocalRunStatus = /* @__PURE__ */ ((LocalRunStatus2) => {
+  LocalRunStatus2["PENDING"] = "pending";
+  LocalRunStatus2["RUNNING"] = "running";
+  LocalRunStatus2["PASSED"] = "passed";
+  LocalRunStatus2["FAILED"] = "failed";
+  LocalRunStatus2["CANCELLED"] = "cancelled";
+  return LocalRunStatus2;
+})(LocalRunStatus || {});
+var LocalRunType = /* @__PURE__ */ ((LocalRunType2) => {
+  LocalRunType2["GENERATION"] = "generation";
+  LocalRunType2["REPLAY"] = "replay";
+  return LocalRunType2;
+})(LocalRunType || {});
+var LocalTestScriptStatus = /* @__PURE__ */ ((LocalTestScriptStatus2) => {
+  LocalTestScriptStatus2["DRAFT"] = "draft";
+  LocalTestScriptStatus2["GENERATED"] = "generated";
+  LocalTestScriptStatus2["VALIDATED"] = "validated";
+  LocalTestScriptStatus2["FAILED"] = "failed";
+  return LocalTestScriptStatus2;
+})(LocalTestScriptStatus || {});
+var LocalWorkflowRunStatus = /* @__PURE__ */ ((LocalWorkflowRunStatus2) => {
+  LocalWorkflowRunStatus2["PENDING"] = "pending";
+  LocalWorkflowRunStatus2["RUNNING"] = "running";
+  LocalWorkflowRunStatus2["COMPLETED"] = "completed";
+  LocalWorkflowRunStatus2["FAILED"] = "failed";
+  LocalWorkflowRunStatus2["CANCELLED"] = "cancelled";
+  return LocalWorkflowRunStatus2;
+})(LocalWorkflowRunStatus || {});
+var CloudMappingEntityType = /* @__PURE__ */ ((CloudMappingEntityType2) => {
+  CloudMappingEntityType2["PROJECT"] = "project";
+  CloudMappingEntityType2["USE_CASE"] = "use_case";
+  CloudMappingEntityType2["TEST_CASE"] = "test_case";
+  CloudMappingEntityType2["TEST_SCRIPT"] = "test_script";
+  return CloudMappingEntityType2;
+})(CloudMappingEntityType || {});
+var LocalWorkflowFileEntityType = /* @__PURE__ */ ((LocalWorkflowFileEntityType2) => {
+  LocalWorkflowFileEntityType2["PROJECT"] = "project";
+  LocalWorkflowFileEntityType2["USE_CASE"] = "use_case";
+  LocalWorkflowFileEntityType2["TEST_CASE"] = "test_case";
+  return LocalWorkflowFileEntityType2;
+})(LocalWorkflowFileEntityType || {});
+var ExecutionStatus = /* @__PURE__ */ ((ExecutionStatus2) => {
+  ExecutionStatus2["Pending"] = "pending";
+  ExecutionStatus2["Running"] = "running";
+  ExecutionStatus2["Completed"] = "completed";
+  ExecutionStatus2["Failed"] = "failed";
+  ExecutionStatus2["Cancelled"] = "cancelled";
+  return ExecutionStatus2;
+})(ExecutionStatus || {});
+var HealthStatus = /* @__PURE__ */ ((HealthStatus2) => {
+  HealthStatus2["Healthy"] = "healthy";
+  HealthStatus2["Degraded"] = "degraded";
+  HealthStatus2["Unhealthy"] = "unhealthy";
+  return HealthStatus2;
+})(HealthStatus || {});
+var TestResultStatus = /* @__PURE__ */ ((TestResultStatus2) => {
+  TestResultStatus2["Passed"] = "passed";
+  TestResultStatus2["Failed"] = "failed";
+  TestResultStatus2["Skipped"] = "skipped";
+  return TestResultStatus2;
+})(TestResultStatus || {});
+
+// src/local-qa/services/auth-service.ts
+var DEFAULT_LOGIN_WAIT_TIMEOUT_MS = 12e4;
+var AuthService = class {
+  /** Path to the auth file. */
+  authFilePath;
+  /** Path to the pending device code file. */
+  pendingDeviceCodePath;
+  /**
+   * Create a new AuthService.
+   */
+  constructor() {
+    const config = getConfig();
+    this.authFilePath = config.localQa.authFilePath;
+    this.pendingDeviceCodePath = path.join(
+      path.dirname(config.localQa.authFilePath),
+      "pending-device-code.json"
+    );
+  }
+  /**
+   * Get current authentication status.
+   */
+  getAuthStatus() {
+    const logger5 = getLogger();
+    const storedAuth = this.loadStoredAuth();
+    if (!storedAuth) {
+      logger5.debug("No stored auth found");
+      return { authenticated: false };
+    }
+    const now = /* @__PURE__ */ new Date();
+    const expiresAt = new Date(storedAuth.expiresAt);
+    const isExpired = now >= expiresAt;
+    logger5.debug("Auth status checked", {
+      email: storedAuth.email,
+      isExpired,
+      expiresAt: storedAuth.expiresAt
+    });
+    return {
+      authenticated: !isExpired,
+      email: storedAuth.email,
+      userId: storedAuth.userId,
+      expiresAt: storedAuth.expiresAt,
+      isExpired
+    };
+  }
+  /**
+   * Start the device code flow.
+   */
+  async startDeviceCodeFlow() {
+    const logger5 = getLogger();
+    const config = getConfig();
+    const { domain, clientId, audience, scopes } = config.localQa.auth0;
+    logger5.info("Starting device code flow");
+    const url = `https://${domain}/oauth/device/code`;
+    const body = new URLSearchParams({
+      client_id: clientId,
+      scope: scopes.join(" "),
+      audience
+    });
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body: body.toString()
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      logger5.error("Device code request failed", {
+        status: response.status,
+        error: errorText
+      });
+      throw new Error(`Failed to start device code flow: ${response.status} ${errorText}`);
+    }
+    const data = await response.json();
+    logger5.info("Device code flow started", {
+      userCode: data.user_code,
+      verificationUri: data.verification_uri,
+      expiresIn: data.expires_in
+    });
+    this.storePendingDeviceCode({
+      deviceCode: data.device_code,
+      userCode: data.user_code,
+      expiresAt: new Date(Date.now() + data.expires_in * 1e3).toISOString()
+    });
+    const browserOpenResult = await openBrowserUrl({
+      url: data.verification_uri_complete
+    });
+    if (browserOpenResult.opened) {
+      logger5.info("Browser opened for device code login");
+    } else {
+      logger5.warn("Failed to open browser for device code login", {
+        error: browserOpenResult.error,
+        verificationUriComplete: data.verification_uri_complete
+      });
+    }
+    return {
+      deviceCode: data.device_code,
+      userCode: data.user_code,
+      verificationUri: data.verification_uri,
+      verificationUriComplete: data.verification_uri_complete,
+      expiresIn: data.expires_in,
+      interval: data.interval,
+      browserOpened: browserOpenResult.opened,
+      browserOpenError: browserOpenResult.error
+    };
+  }
+  /**
+   * Store a pending device code for later retrieval.
+   */
+  storePendingDeviceCode(params) {
+    const logger5 = getLogger();
+    const dir = path.dirname(this.pendingDeviceCodePath);
+    if (!fs4.existsSync(dir)) {
+      fs4.mkdirSync(dir, { recursive: true });
+    }
+    fs4.writeFileSync(this.pendingDeviceCodePath, JSON.stringify(params, null, 2), {
+      encoding: "utf-8",
+      mode: 384
+    });
+    logger5.debug("Pending device code stored", { userCode: params.userCode });
+  }
+  /**
+   * Get the pending device code if one exists and is not expired.
+   */
+  getPendingDeviceCode() {
+    const logger5 = getLogger();
+    if (!fs4.existsSync(this.pendingDeviceCodePath)) {
+      logger5.debug("No pending device code found");
+      return null;
+    }
+    try {
+      const content = fs4.readFileSync(this.pendingDeviceCodePath, "utf-8");
+      const data = JSON.parse(content);
+      const now = /* @__PURE__ */ new Date();
+      const expiresAt = new Date(data.expiresAt);
+      if (now >= expiresAt) {
+        logger5.debug("Pending device code expired");
+        this.clearPendingDeviceCode();
+        return null;
+      }
+      return data.deviceCode;
+    } catch (error) {
+      logger5.warn("Failed to read pending device code", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return null;
+    }
+  }
+  /**
+   * Clear the pending device code file.
+   */
+  clearPendingDeviceCode() {
+    const logger5 = getLogger();
+    if (fs4.existsSync(this.pendingDeviceCodePath)) {
+      try {
+        fs4.unlinkSync(this.pendingDeviceCodePath);
+        logger5.debug("Pending device code cleared");
+      } catch (error) {
+        logger5.warn("Failed to clear pending device code", {
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+  }
+  /**
+   * Poll for device code authorization completion.
+   */
+  async pollDeviceCode(deviceCode) {
+    const logger5 = getLogger();
+    const config = getConfig();
+    const { domain, clientId } = config.localQa.auth0;
+    logger5.debug("Polling for device code authorization");
+    const url = `https://${domain}/oauth/token`;
+    const body = new URLSearchParams({
+      grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+      client_id: clientId,
+      device_code: deviceCode
+    });
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded"
+        },
+        body: body.toString()
+      });
+      if (response.ok) {
+        const tokenData = await response.json();
+        const tokenResponse = {
+          accessToken: tokenData.access_token,
+          refreshToken: tokenData.refresh_token,
+          tokenType: tokenData.token_type,
+          expiresIn: tokenData.expires_in
+        };
+        const userInfo = await this.getUserInfo(tokenResponse.accessToken);
+        await this.storeAuth({
+          tokenResponse,
+          email: userInfo.email,
+          userId: userInfo.sub
+        });
+        this.clearPendingDeviceCode();
+        logger5.info("Device code authorization complete", { email: userInfo.email });
+        return {
+          status: "complete" /* Complete */,
+          message: "Authentication successful!",
+          email: userInfo.email
+        };
+      }
+      const errorData = await response.json();
+      if (errorData.error === "authorization_pending") {
+        logger5.debug("Authorization pending");
+        return {
+          status: "pending" /* Pending */,
+          message: "Waiting for user to complete authorization..."
+        };
+      }
+      if (errorData.error === "slow_down") {
+        logger5.debug("Polling too fast");
+        return {
+          status: "pending" /* Pending */,
+          message: "Polling too fast, slowing down..."
+        };
+      }
+      if (errorData.error === "expired_token") {
+        logger5.warn("Device code expired");
+        return {
+          status: "expired" /* Expired */,
+          message: "The authorization code has expired. Please start again."
+        };
+      }
+      if (errorData.error === "access_denied") {
+        logger5.warn("Access denied");
+        return {
+          status: "error" /* Error */,
+          message: "Access was denied by the user.",
+          error: errorData.error_description ?? errorData.error
+        };
+      }
+      logger5.error("Unexpected error during polling", { error: errorData });
+      return {
+        status: "error" /* Error */,
+        message: errorData.error_description ?? errorData.error,
+        error: errorData.error
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      logger5.error("Poll request failed", { error: errorMessage });
+      return {
+        status: "error" /* Error */,
+        message: `Poll request failed: ${errorMessage}`,
+        error: errorMessage
+      };
+    }
+  }
+  /**
+   * Poll for device code authorization until completion or timeout.
+   */
+  async waitForDeviceCodeAuthorization(params) {
+    const logger5 = getLogger();
+    const timeoutMs = params.timeoutMs ?? DEFAULT_LOGIN_WAIT_TIMEOUT_MS;
+    const pollIntervalMs = Math.max(params.intervalSeconds, 1) * 1e3;
+    const startedAt = Date.now();
+    logger5.info("Waiting for device code authorization", {
+      timeoutMs,
+      pollIntervalMs
+    });
+    while (Date.now() - startedAt < timeoutMs) {
+      const result = await this.pollDeviceCode(params.deviceCode);
+      if (result.status !== "pending" /* Pending */) {
+        return result;
+      }
+      const remainingMs = timeoutMs - (Date.now() - startedAt);
+      if (remainingMs <= 0) {
+        break;
+      }
+      await sleep({ durationMs: Math.min(pollIntervalMs, remainingMs) });
+    }
+    return {
+      status: "pending" /* Pending */,
+      message: "Timed out waiting for browser login confirmation. Please finish login in your browser, then call `muggle_auth_poll` to continue."
+    };
+  }
+  /**
+   * Get user info from Auth0.
+   */
+  async getUserInfo(accessToken) {
+    const logger5 = getLogger();
+    const config = getConfig();
+    const { domain } = config.localQa.auth0;
+    const url = `https://${domain}/userinfo`;
+    try {
+      const response = await fetch(url, {
+        method: "GET",
+        headers: {
+          Authorization: `Bearer ${accessToken}`
+        }
+      });
+      if (!response.ok) {
+        logger5.warn("Failed to get user info", { status: response.status });
+        return {};
+      }
+      const data = await response.json();
+      return data;
+    } catch (error) {
+      logger5.warn("User info request failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return {};
+    }
+  }
+  /**
+   * Store authentication tokens.
+   */
+  async storeAuth(params) {
+    const { tokenResponse, email, userId } = params;
+    const logger5 = getLogger();
+    const expiresAt = new Date(Date.now() + tokenResponse.expiresIn * 1e3).toISOString();
+    const storedAuth = {
+      accessToken: tokenResponse.accessToken,
+      refreshToken: tokenResponse.refreshToken,
+      expiresAt,
+      email,
+      userId
+    };
+    const dir = path.dirname(this.authFilePath);
+    if (!fs4.existsSync(dir)) {
+      fs4.mkdirSync(dir, { recursive: true });
+    }
+    fs4.writeFileSync(this.authFilePath, JSON.stringify(storedAuth, null, 2), {
+      encoding: "utf-8",
+      mode: 384
+    });
+    logger5.info("Auth stored successfully", { email, expiresAt });
+  }
+  /**
+   * Load stored authentication.
+   */
+  loadStoredAuth() {
+    const logger5 = getLogger();
+    if (!fs4.existsSync(this.authFilePath)) {
+      return null;
+    }
+    try {
+      const content = fs4.readFileSync(this.authFilePath, "utf-8");
+      return JSON.parse(content);
+    } catch (error) {
+      logger5.error("Failed to load stored auth", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return null;
+    }
+  }
+  /**
+   * Get the current access token (if valid).
+   */
+  getAccessToken() {
+    const storedAuth = this.loadStoredAuth();
+    if (!storedAuth) {
+      return null;
+    }
+    const now = /* @__PURE__ */ new Date();
+    const expiresAt = new Date(storedAuth.expiresAt);
+    if (now >= expiresAt) {
+      return null;
+    }
+    return storedAuth.accessToken;
+  }
+  /**
+   * Clear stored authentication (logout).
+   */
+  logout() {
+    const logger5 = getLogger();
+    if (!fs4.existsSync(this.authFilePath)) {
+      logger5.debug("No auth to clear");
+      return false;
+    }
+    try {
+      fs4.unlinkSync(this.authFilePath);
+      logger5.info("Auth cleared successfully");
+      return true;
+    } catch (error) {
+      logger5.error("Failed to clear auth", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return false;
+    }
+  }
+};
+var serviceInstance = null;
+function getAuthService() {
+  serviceInstance ??= new AuthService();
+  return serviceInstance;
+}
+function resetAuthService() {
+  serviceInstance = null;
+}
+function sleep(params) {
+  return new Promise((resolve2) => {
+    setTimeout(() => {
+      resolve2();
+    }, params.durationMs);
+  });
+}
+var DEFAULT_SESSION_MAX_AGE_DAYS = 30;
+var StorageService = class {
+  /** Base data directory. */
+  dataDir;
+  /** Sessions directory. */
+  sessionsDir;
+  /**
+   * Create a new StorageService.
+   */
+  constructor() {
+    const config = getConfig();
+    this.dataDir = config.localQa.dataDir;
+    this.sessionsDir = config.localQa.sessionsDir;
+  }
+  /**
+   * Ensure the base directories exist.
+   */
+  ensureDirectories() {
+    const logger5 = getLogger();
+    if (!fs4.existsSync(this.dataDir)) {
+      fs4.mkdirSync(this.dataDir, { recursive: true });
+      logger5.info("Created data directory", { path: this.dataDir });
+    }
+    if (!fs4.existsSync(this.sessionsDir)) {
+      fs4.mkdirSync(this.sessionsDir, { recursive: true });
+      logger5.info("Created sessions directory", { path: this.sessionsDir });
+    }
+  }
+  /**
+   * Create a new session directory.
+   * @param sessionId - Unique session ID.
+   * @returns Path to the session directory.
+   */
+  createSessionDirectory(sessionId) {
+    const logger5 = getLogger();
+    this.ensureDirectories();
+    const sessionDir = path.join(this.sessionsDir, sessionId);
+    if (!fs4.existsSync(sessionDir)) {
+      fs4.mkdirSync(sessionDir, { recursive: true });
+      fs4.mkdirSync(path.join(sessionDir, "screenshots"), { recursive: true });
+      fs4.mkdirSync(path.join(sessionDir, "logs"), { recursive: true });
+      logger5.info("Created session directory", { sessionId, path: sessionDir });
+    }
+    return sessionDir;
+  }
+  /**
+   * Save session metadata.
+   * @param metadata - Session metadata to save.
+   */
+  saveSessionMetadata(metadata) {
+    const logger5 = getLogger();
+    const sessionDir = this.createSessionDirectory(metadata.sessionId);
+    const metadataPath = path.join(sessionDir, "metadata.json");
+    fs4.writeFileSync(metadataPath, JSON.stringify(metadata, null, 2), "utf-8");
+    logger5.debug("Saved session metadata", { sessionId: metadata.sessionId });
+  }
+  /**
+   * Load session metadata.
+   * @param sessionId - Session ID to load.
+   * @returns Session metadata, or null if not found.
+   */
+  loadSessionMetadata(sessionId) {
+    const logger5 = getLogger();
+    const metadataPath = path.join(this.sessionsDir, sessionId, "metadata.json");
+    if (!fs4.existsSync(metadataPath)) {
+      return null;
+    }
+    try {
+      const content = fs4.readFileSync(metadataPath, "utf-8");
+      return JSON.parse(content);
+    } catch (error) {
+      logger5.error("Failed to load session metadata", {
+        sessionId,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return null;
+    }
+  }
+  /**
+   * List all sessions.
+   * @returns Array of session IDs.
+   */
+  listSessions() {
+    if (!fs4.existsSync(this.sessionsDir)) {
+      return [];
+    }
+    return fs4.readdirSync(this.sessionsDir).filter((entry) => {
+      const entryPath = path.join(this.sessionsDir, entry);
+      return fs4.statSync(entryPath).isDirectory();
+    });
+  }
+  /**
+   * Get the current session ID (if any).
+   * @returns Current session ID, or null.
+   */
+  getCurrentSessionId() {
+    const currentPath = path.join(this.sessionsDir, "current");
+    if (!fs4.existsSync(currentPath)) {
+      return null;
+    }
+    try {
+      const target = fs4.readlinkSync(currentPath);
+      return path.basename(target);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Set the current session.
+   * @param sessionId - Session ID to set as current.
+   */
+  setCurrentSession(sessionId) {
+    const logger5 = getLogger();
+    const currentPath = path.join(this.sessionsDir, "current");
+    const targetPath = path.join(this.sessionsDir, sessionId);
+    if (fs4.existsSync(currentPath)) {
+      fs4.unlinkSync(currentPath);
+    }
+    fs4.symlinkSync(targetPath, currentPath);
+    logger5.info("Set current session", { sessionId });
+  }
+  /**
+   * Save a screenshot to the session directory.
+   * @param params - Screenshot save parameters.
+   */
+  saveScreenshot(params) {
+    const { sessionId, filename, data } = params;
+    const logger5 = getLogger();
+    const sessionDir = this.createSessionDirectory(sessionId);
+    const screenshotPath = path.join(sessionDir, "screenshots", filename);
+    fs4.writeFileSync(screenshotPath, data);
+    logger5.debug("Saved screenshot", { sessionId, filename });
+    return screenshotPath;
+  }
+  /**
+   * Append to the results markdown file.
+   * @param params - Results append parameters.
+   */
+  appendToResults(params) {
+    const { sessionId, content } = params;
+    const logger5 = getLogger();
+    const sessionDir = this.createSessionDirectory(sessionId);
+    const resultsPath = path.join(sessionDir, "results.md");
+    fs4.appendFileSync(resultsPath, content + "\n", "utf-8");
+    logger5.debug("Appended to results", { sessionId });
+  }
+  /**
+   * Get the results markdown content.
+   * @param sessionId - Session ID.
+   * @returns Results content, or null if not found.
+   */
+  getResults(sessionId) {
+    const resultsPath = path.join(this.sessionsDir, sessionId, "results.md");
+    if (!fs4.existsSync(resultsPath)) {
+      return null;
+    }
+    return fs4.readFileSync(resultsPath, "utf-8");
+  }
+  /**
+   * Get the data directory path.
+   * @returns Data directory path.
+   */
+  getDataDir() {
+    return this.dataDir;
+  }
+  /**
+   * Get the sessions directory path.
+   * @returns Sessions directory path.
+   */
+  getSessionsDir() {
+    return this.sessionsDir;
+  }
+  /**
+   * Create a new session with metadata.
+   * @param params - Session creation parameters.
+   * @returns Path to the session directory.
+   */
+  createSession(params) {
+    const { sessionId, targetUrl, testInstructions } = params;
+    const logger5 = getLogger();
+    const sessionDir = this.createSessionDirectory(sessionId);
+    const metadata = {
+      sessionId,
+      workflowRunId: sessionId,
+      status: "running" /* Running */,
+      startTime: (/* @__PURE__ */ new Date()).toISOString(),
+      targetUrl,
+      testInstructions
+    };
+    this.saveSessionMetadata(metadata);
+    this.setCurrentSession(sessionId);
+    logger5.info("Created session", { sessionId, targetUrl });
+    return sessionDir;
+  }
+  /**
+   * Update the status of an existing session.
+   * @param params - Status update parameters.
+   */
+  updateSessionStatus(params) {
+    const { sessionId, status } = params;
+    const logger5 = getLogger();
+    const metadata = this.loadSessionMetadata(sessionId);
+    if (!metadata) {
+      logger5.warn("Session not found for status update", { sessionId });
+      return;
+    }
+    metadata.status = status;
+    if (status === "completed" /* Completed */ || status === "failed" /* Failed */) {
+      metadata.endTime = (/* @__PURE__ */ new Date()).toISOString();
+    }
+    this.saveSessionMetadata(metadata);
+    logger5.debug("Updated session status", { sessionId, status });
+  }
+  /**
+   * Initialize the results.md file with a header.
+   * @param params - Initialization parameters.
+   */
+  initializeResults(params) {
+    const { sessionId, targetUrl, testInstructions } = params;
+    const logger5 = getLogger();
+    const sessionDir = this.createSessionDirectory(sessionId);
+    const resultsPath = path.join(sessionDir, "results.md");
+    const header = [
+      `# Test Results: ${sessionId}`,
+      "",
+      `**Target URL:** ${targetUrl}`,
+      `**Started:** ${(/* @__PURE__ */ new Date()).toISOString()}`,
+      `**Instructions:** ${testInstructions}`,
+      "",
+      "---",
+      "",
+      "## Test Steps",
+      ""
+    ].join("\n");
+    fs4.writeFileSync(resultsPath, header, "utf-8");
+    logger5.debug("Initialized results.md", { sessionId });
+  }
+  /**
+   * Append a test step to the results.md file.
+   * @param params - Step parameters.
+   */
+  appendStepToResults(params) {
+    const { sessionId, step } = params;
+    const logger5 = getLogger();
+    const sessionDir = this.createSessionDirectory(sessionId);
+    const resultsPath = path.join(sessionDir, "results.md");
+    const statusIcon = step.success ? "\u2713" : "\u2717";
+    const stepContent = [
+      `### Step ${step.stepNumber}: ${step.action}`,
+      "",
+      step.target ? `- **Target:** ${step.target}` : "",
+      `- **Result:** ${step.result} ${statusIcon}`,
+      step.screenshotPath ? `- **Screenshot:** [step-${String(step.stepNumber).padStart(3, "0")}.png](screenshots/step-${String(step.stepNumber).padStart(3, "0")}.png)` : "",
+      ""
+    ].filter(Boolean).join("\n");
+    fs4.appendFileSync(resultsPath, stepContent + "\n", "utf-8");
+    logger5.debug("Appended step to results", { sessionId, stepNumber: step.stepNumber });
+    const metadata = this.loadSessionMetadata(sessionId);
+    if (metadata) {
+      metadata.stepsCount = (metadata.stepsCount ?? 0) + 1;
+      this.saveSessionMetadata(metadata);
+    }
+  }
+  /**
+   * Finalize the results.md file with a summary.
+   * @param params - Finalization parameters.
+   */
+  finalizeResults(params) {
+    const { sessionId, status, summary } = params;
+    const logger5 = getLogger();
+    const sessionDir = path.join(this.sessionsDir, sessionId);
+    const resultsPath = path.join(sessionDir, "results.md");
+    if (!fs4.existsSync(resultsPath)) {
+      logger5.warn("Results file not found for finalization", { sessionId });
+      return;
+    }
+    const metadata = this.loadSessionMetadata(sessionId);
+    const endTime = /* @__PURE__ */ new Date();
+    const startTime = metadata?.startTime ? new Date(metadata.startTime) : endTime;
+    const durationMs = endTime.getTime() - startTime.getTime();
+    const durationSeconds = (durationMs / 1e3).toFixed(2);
+    const statusDisplay = status === "completed" /* Completed */ ? "\u2713 Passed" : status === "failed" /* Failed */ ? "\u2717 Failed" : "\u2014 Running";
+    const footer = [
+      "",
+      "---",
+      "",
+      "## Summary",
+      "",
+      `**Status:** ${statusDisplay}`,
+      `**Duration:** ${durationSeconds}s`,
+      `**Steps:** ${metadata?.stepsCount ?? 0}`,
+      `**Completed:** ${endTime.toISOString()}`,
+      "",
+      summary ? summary : ""
+    ].join("\n");
+    fs4.appendFileSync(resultsPath, footer, "utf-8");
+    logger5.debug("Finalized results.md", { sessionId, status });
+    if (metadata) {
+      metadata.durationMs = durationMs;
+      metadata.endTime = endTime.toISOString();
+      metadata.status = status;
+      this.saveSessionMetadata(metadata);
+    }
+  }
+  /**
+   * List all sessions with their metadata.
+   * @returns Array of session summaries.
+   */
+  listSessionsWithMetadata() {
+    const sessionIds = this.listSessions();
+    const summaries = [];
+    for (const sessionId of sessionIds) {
+      if (sessionId === "current") {
+        continue;
+      }
+      const metadata = this.loadSessionMetadata(sessionId);
+      if (metadata) {
+        summaries.push({
+          sessionId: metadata.sessionId,
+          status: metadata.status,
+          startTime: metadata.startTime,
+          endTime: metadata.endTime,
+          targetUrl: metadata.targetUrl,
+          durationMs: metadata.durationMs,
+          stepsCount: metadata.stepsCount
+        });
+      }
+    }
+    summaries.sort((a, b) => new Date(b.startTime).getTime() - new Date(a.startTime).getTime());
+    return summaries;
+  }
+  /**
+   * Cleanup old sessions beyond the specified age.
+   * @param params - Cleanup parameters.
+   * @returns Number of sessions deleted.
+   */
+  cleanupOldSessions(params) {
+    const maxAgeDays = params?.maxAgeDays ?? DEFAULT_SESSION_MAX_AGE_DAYS;
+    const logger5 = getLogger();
+    const cutoffDate = /* @__PURE__ */ new Date();
+    cutoffDate.setDate(cutoffDate.getDate() - maxAgeDays);
+    const sessionIds = this.listSessions();
+    let deletedCount = 0;
+    for (const sessionId of sessionIds) {
+      if (sessionId === "current") {
+        continue;
+      }
+      const metadata = this.loadSessionMetadata(sessionId);
+      if (!metadata) {
+        continue;
+      }
+      const sessionDate = new Date(metadata.startTime);
+      if (sessionDate < cutoffDate) {
+        const sessionDir = path.join(this.sessionsDir, sessionId);
+        try {
+          fs4.rmSync(sessionDir, { recursive: true, force: true });
+          deletedCount++;
+          logger5.info("Deleted old session", {
+            sessionId,
+            age: Math.floor((Date.now() - sessionDate.getTime()) / (1e3 * 60 * 60 * 24))
+          });
+        } catch (error) {
+          logger5.error("Failed to delete session", {
+            sessionId,
+            error: error instanceof Error ? error.message : String(error)
+          });
+        }
+      }
+    }
+    if (deletedCount > 0) {
+      logger5.info("Session cleanup completed", {
+        deletedCount,
+        maxAgeDays
+      });
+    }
+    return deletedCount;
+  }
+  /**
+   * Get a session directory path.
+   * @param sessionId - Session ID.
+   * @returns Session directory path.
+   */
+  getSessionPath(sessionId) {
+    return path.join(this.sessionsDir, sessionId);
+  }
+  /**
+   * Delete a specific session.
+   * @param sessionId - Session ID to delete.
+   * @returns Whether deletion succeeded.
+   */
+  deleteSession(sessionId) {
+    const logger5 = getLogger();
+    const sessionDir = path.join(this.sessionsDir, sessionId);
+    if (!fs4.existsSync(sessionDir)) {
+      logger5.warn("Session not found for deletion", { sessionId });
+      return false;
+    }
+    try {
+      const currentId = this.getCurrentSessionId();
+      if (currentId === sessionId) {
+        const currentPath = path.join(this.sessionsDir, "current");
+        if (fs4.existsSync(currentPath)) {
+          fs4.unlinkSync(currentPath);
+        }
+      }
+      fs4.rmSync(sessionDir, { recursive: true, force: true });
+      logger5.info("Deleted session", { sessionId });
+      return true;
+    } catch (error) {
+      logger5.error("Failed to delete session", {
+        sessionId,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return false;
+    }
+  }
+};
+var serviceInstance2 = null;
+function getStorageService() {
+  serviceInstance2 ??= new StorageService();
+  return serviceInstance2;
+}
+function resetStorageService() {
+  serviceInstance2 = null;
+}
+var logger4 = getLogger();
+var RunResultStorageService = class {
+  /** Base directory for run results. */
+  runResultsDir;
+  /** Base directory for test scripts. */
+  testScriptsDir;
+  constructor() {
+    const storageService = getStorageService();
+    const dataDir = storageService.getDataDir();
+    this.runResultsDir = path.join(dataDir, "run-results");
+    this.testScriptsDir = path.join(dataDir, "test-scripts");
+    this.ensureDirectories();
+  }
+  /**
+   * Ensure storage directories exist.
+   */
+  ensureDirectories() {
+    if (!fs4.existsSync(this.runResultsDir)) {
+      fs4.mkdirSync(this.runResultsDir, { recursive: true });
+    }
+    if (!fs4.existsSync(this.testScriptsDir)) {
+      fs4.mkdirSync(this.testScriptsDir, { recursive: true });
+    }
+  }
+  // ========================================
+  // Run Results
+  // ========================================
+  /**
+   * List all run results.
+   */
+  listRunResults() {
+    try {
+      const files = fs4.readdirSync(this.runResultsDir).filter((f) => f.endsWith(".json"));
+      const results = [];
+      for (const file of files) {
+        try {
+          const content = fs4.readFileSync(path.join(this.runResultsDir, file), "utf-8");
+          results.push(JSON.parse(content));
+        } catch {
+          logger4.warn("Failed to read run result file", { file });
+        }
+      }
+      return results.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Get a run result by ID.
+   */
+  getRunResult(runId) {
+    const filePath = path.join(this.runResultsDir, `${runId}.json`);
+    if (!fs4.existsSync(filePath)) {
+      return void 0;
+    }
+    try {
+      const content = fs4.readFileSync(filePath, "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+   * Save a run result.
+   */
+  saveRunResult(result) {
+    const filePath = path.join(this.runResultsDir, `${result.id}.json`);
+    fs4.writeFileSync(filePath, JSON.stringify(result, null, 2));
+  }
+  /**
+   * Create a new run result.
+   */
+  createRunResult(params) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const id = `run_${Date.now()}_${Math.random().toString(36).substring(2, 8)}`;
+    const result = {
+      id,
+      runType: params.runType,
+      status: "pending",
+      cloudTestCaseId: params.cloudTestCaseId,
+      localUrl: params.localUrl,
+      createdAt: now,
+      updatedAt: now
+    };
+    this.saveRunResult(result);
+    return result;
+  }
+  /**
+   * Update a run result.
+   */
+  updateRunResult(runId, updates) {
+    const result = this.getRunResult(runId);
+    if (!result) {
+      return void 0;
+    }
+    const updated = {
+      ...result,
+      ...updates,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.saveRunResult(updated);
+    return updated;
+  }
+  // ========================================
+  // Test Scripts
+  // ========================================
+  /**
+   * List all test scripts.
+   */
+  listTestScripts() {
+    try {
+      const files = fs4.readdirSync(this.testScriptsDir).filter((f) => f.endsWith(".json"));
+      const scripts = [];
+      for (const file of files) {
+        try {
+          const content = fs4.readFileSync(path.join(this.testScriptsDir, file), "utf-8");
+          scripts.push(JSON.parse(content));
+        } catch {
+          logger4.warn("Failed to read test script file", { file });
+        }
+      }
+      return scripts.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Get a test script by ID.
+   */
+  getTestScript(testScriptId) {
+    const filePath = path.join(this.testScriptsDir, `${testScriptId}.json`);
+    if (!fs4.existsSync(filePath)) {
+      return void 0;
+    }
+    try {
+      const content = fs4.readFileSync(filePath, "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+   * Save a test script.
+   */
+  saveTestScript(script) {
+    const filePath = path.join(this.testScriptsDir, `${script.id}.json`);
+    fs4.writeFileSync(filePath, JSON.stringify(script, null, 2));
+  }
+  /**
+   * Create a new test script.
+   */
+  createTestScript(params) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const id = `ts_${Date.now()}_${Math.random().toString(36).substring(2, 8)}`;
+    const script = {
+      id,
+      name: params.name,
+      url: params.url,
+      status: "pending",
+      cloudTestCaseId: params.cloudTestCaseId,
+      goal: params.goal,
+      createdAt: now,
+      updatedAt: now
+    };
+    this.saveTestScript(script);
+    return script;
+  }
+  /**
+   * Update a test script.
+   */
+  updateTestScript(testScriptId, updates) {
+    const script = this.getTestScript(testScriptId);
+    if (!script) {
+      return void 0;
+    }
+    const updated = {
+      ...script,
+      ...updates,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.saveTestScript(updated);
+    return updated;
+  }
+};
+var instance = null;
+function getRunResultStorageService() {
+  if (!instance) {
+    instance = new RunResultStorageService();
+  }
+  return instance;
+}
+function resetRunResultStorageService() {
+  instance = null;
+}
+var activeProcesses = /* @__PURE__ */ new Map();
+function getAuthenticatedUserId() {
+  const authService = getAuthService();
+  const authStatus = authService.getAuthStatus();
+  if (!authStatus.authenticated) {
+    throw new Error("Not authenticated. Please run qa_auth_login first.");
+  }
+  if (!authStatus.userId) {
+    throw new Error("User ID not found in auth. Please re-authenticate.");
+  }
+  return authStatus.userId;
+}
+function buildStudioAuthContent() {
+  const authService = getAuthService();
+  const authStatus = authService.getAuthStatus();
+  const storedAuth = authService.loadStoredAuth();
+  if (!authStatus.authenticated || !storedAuth) {
+    throw new Error("Not authenticated. Please run qa_auth_login first.");
+  }
+  if (!storedAuth.email || !storedAuth.userId) {
+    throw new Error("Auth data incomplete. Please re-authenticate.");
+  }
+  return {
+    accessToken: storedAuth.accessToken,
+    email: storedAuth.email,
+    userId: storedAuth.userId
+  };
+}
+async function ensureTempDir() {
+  const config = getConfig();
+  const tempDir = path.join(config.localQa.dataDir, "temp");
+  await fs6.mkdir(tempDir, { recursive: true });
+  return tempDir;
+}
+async function writeTempFile(params) {
+  const tempDir = await ensureTempDir();
+  const filePath = path.join(tempDir, params.filename);
+  await fs6.writeFile(filePath, JSON.stringify(params.data, null, 2));
+  return filePath;
+}
+async function cleanupTempFiles(params) {
+  for (const filePath of params.filePaths) {
+    try {
+      await fs6.unlink(filePath);
+    } catch {
+    }
+  }
+}
+async function executeTestGeneration(params) {
+  const { testCase, localUrl } = params;
+  getAuthenticatedUserId();
+  const authContent = buildStudioAuthContent();
+  const storage = getRunResultStorageService();
+  const runResult = storage.createRunResult({
+    runType: "generation",
+    cloudTestCaseId: testCase.id,
+    localUrl
+  });
+  try {
+    const localTestScript = storage.createTestScript({
+      name: `Script for ${testCase.title}`,
+      url: localUrl,
+      cloudTestCaseId: testCase.id,
+      goal: testCase.goal
+    });
+    const actionScript = {
+      steps: [
+        {
+          type: "navigate",
+          url: localUrl
+        },
+        {
+          type: "explore",
+          goal: testCase.goal,
+          instructions: testCase.instructions,
+          expectedResult: testCase.expectedResult
+        }
+      ]
+    };
+    const runId = runResult.id;
+    const startedAt = Date.now();
+    const inputFilePath = await writeTempFile({
+      filename: `${runId}_input.json`,
+      data: actionScript
+    });
+    const authFilePath = await writeTempFile({
+      filename: `${runId}_auth.json`,
+      data: authContent
+    });
+    const completedAt = Date.now();
+    const executionTimeMs = completedAt - startedAt;
+    storage.updateRunResult(runId, {
+      status: "failed",
+      testScriptId: localTestScript.id,
+      executionTimeMs,
+      errorMessage: "Electron-app execution not yet implemented."
+    });
+    await cleanupTempFiles({ filePaths: [inputFilePath, authFilePath] });
+    return {
+      id: runId,
+      testScriptId: localTestScript.id,
+      status: "failed",
+      executionTimeMs,
+      errorMessage: "Electron-app execution not yet implemented."
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    storage.updateRunResult(runResult.id, {
+      status: "failed",
+      errorMessage
+    });
+    return {
+      id: runResult.id,
+      status: "failed",
+      executionTimeMs: 0,
+      errorMessage
+    };
+  }
+}
+async function executeReplay(params) {
+  const { testScript, localUrl } = params;
+  getAuthenticatedUserId();
+  const authContent = buildStudioAuthContent();
+  const storage = getRunResultStorageService();
+  const runResult = storage.createRunResult({
+    runType: "replay",
+    cloudTestCaseId: testScript.testCaseId,
+    localUrl
+  });
+  try {
+    const runId = runResult.id;
+    const startedAt = Date.now();
+    const rewrittenActionScript = rewriteActionScriptUrls({
+      actionScript: testScript.actionScript,
+      originalUrl: testScript.url,
+      localUrl
+    });
+    const inputFilePath = await writeTempFile({
+      filename: `${runId}_input.json`,
+      data: rewrittenActionScript
+    });
+    const authFilePath = await writeTempFile({
+      filename: `${runId}_auth.json`,
+      data: authContent
+    });
+    const completedAt = Date.now();
+    const executionTimeMs = completedAt - startedAt;
+    storage.updateRunResult(runId, {
+      status: "failed",
+      executionTimeMs,
+      errorMessage: "Electron-app execution not yet implemented."
+    });
+    await cleanupTempFiles({ filePaths: [inputFilePath, authFilePath] });
+    return {
+      id: runId,
+      status: "failed",
+      executionTimeMs,
+      errorMessage: "Electron-app execution not yet implemented."
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    storage.updateRunResult(runResult.id, {
+      status: "failed",
+      errorMessage
+    });
+    return {
+      id: runResult.id,
+      status: "failed",
+      executionTimeMs: 0,
+      errorMessage
+    };
+  }
+}
+function rewriteActionScriptUrls(params) {
+  const { actionScript, originalUrl, localUrl } = params;
+  if (!originalUrl) {
+    return actionScript;
+  }
+  const serialized = JSON.stringify(actionScript);
+  const rewritten = serialized.replace(new RegExp(escapeRegex(originalUrl), "g"), localUrl);
+  return JSON.parse(rewritten);
+}
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function cancelExecution(params) {
+  const process2 = activeProcesses.get(params.runId);
+  if (!process2) {
+    return false;
+  }
+  process2.process.kill("SIGTERM");
+  process2.status = "cancelled";
+  activeProcesses.delete(params.runId);
+  const storage = getRunResultStorageService();
+  storage.updateRunResult(params.runId, {
+    status: "cancelled",
+    errorMessage: "Execution cancelled by user."
+  });
+  return true;
+}
+function listActiveExecutions() {
+  return Array.from(activeProcesses.entries()).map(([runId, process2]) => ({
+    runId,
+    status: process2.status
+  }));
+}
+
+// src/qa/tools/tool-registry.ts
+var MUGGLE_TEST_PREFIX = "/v1/protected/muggle-test";
+var getWorkflowTimeoutMs = () => getConfig().qa.workflowTimeoutMs;
+var projectTools = [
+  {
+    name: "qa_project_create",
+    description: "Create a new QA testing project. Projects organize use cases, test cases, and test scripts.",
+    inputSchema: ProjectCreateInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "POST",
+        path: `${MUGGLE_TEST_PREFIX}/projects`,
+        body: {
+          name: data.projectName,
+          description: data.description,
+          url: data.url
+        }
+      };
+    }
+  },
+  {
+    name: "qa_project_get",
+    description: "Get details of a specific project by ID.",
+    inputSchema: ProjectGetInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "GET",
+        path: `${MUGGLE_TEST_PREFIX}/projects/${data.projectId}`
+      };
+    }
+  },
+  {
+    name: "qa_project_update",
+    description: "Update an existing project's details.",
+    inputSchema: ProjectUpdateInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      const body = { id: data.projectId };
+      if (data.projectName !== void 0) body.name = data.projectName;
+      if (data.description !== void 0) body.description = data.description;
+      if (data.url !== void 0) body.url = data.url;
+      return {
+        method: "PUT",
+        path: `${MUGGLE_TEST_PREFIX}/projects/${data.projectId}`,
+        body
+      };
+    }
+  },
+  {
+    name: "qa_project_list",
+    description: "List all projects accessible to the authenticated user.",
+    inputSchema: ProjectListInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "GET",
+        path: `${MUGGLE_TEST_PREFIX}/projects`,
+        queryParams: { page: data.page, pageSize: data.pageSize }
+      };
+    }
+  },
+  {
+    name: "qa_project_delete",
+    description: "Delete a project and all associated entities. This is a soft delete.",
+    inputSchema: ProjectDeleteInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "DELETE",
+        path: `${MUGGLE_TEST_PREFIX}/projects/${data.projectId}`
+      };
+    }
+  }
+];
+var useCaseTools = [
+  {
+    name: "qa_use_case_discovery_memory_get",
+    description: "Get the use case discovery memory for a project, including all discovered use case candidates.",
+    inputSchema: UseCaseDiscoveryMemoryGetInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "GET",
+        path: `${MUGGLE_TEST_PREFIX}/projects/${data.projectId}/use-case-discovery-memory`
+      };
+    }
+  },
+  {
+    name: "qa_use_case_candidates_approve",
+    description: "Approve (graduate) selected use case candidates into actual use cases.",
+    inputSchema: UseCaseCandidatesApproveInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "POST",
+        path: `${MUGGLE_TEST_PREFIX}/projects/${data.projectId}/use-case-discovery-memory/graduate`,
+        body: { approveIds: data.approvedCandidateIds }
+      };
+    }
+  },
+  {
+    name: "qa_use_case_list",
+    description: "List all use cases for a project.",
+    inputSchema: UseCaseListInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "GET",
+        path: `${MUGGLE_TEST_PREFIX}/use-cases`,
+        queryParams: { projectId: data.projectId, page: data.page, pageSize: data.pageSize }
+      };
+    }
+  },
+  {
+    name: "qa_use_case_get",
+    description: "Get details of a specific use case by ID.",
+    inputSchema: UseCaseGetInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "GET",
+        path: `${MUGGLE_TEST_PREFIX}/use-cases/${data.useCaseId}`
+      };
+    }
+  },
+  {
+    name: "qa_use_case_prompt_preview",
+    description: "Preview a use case generated from a natural language instruction without saving.",
+    inputSchema: UseCasePromptPreviewInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "POST",
+        path: `${MUGGLE_TEST_PREFIX}/projects/${data.projectId}/use-cases/prompt/preview`,
+        body: { instruction: data.instruction }
+      };
+    }
+  },
+  {
+    name: "qa_use_case_create_from_prompts",
+    description: "Create one or more use cases from natural language instructions.",
+    inputSchema: UseCaseCreateFromPromptsInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "POST",
+        path: `${MUGGLE_TEST_PREFIX}/projects/${data.projectId}/use-cases/prompts/bulk`,
+        body: { projectId: data.projectId, prompts: data.prompts }
+      };
+    }
+  },
+  {
+    name: "qa_use_case_update_from_prompt",
+    description: "Update an existing use case by regenerating its fields from a new instruction.",
+    inputSchema: UseCaseUpdateFromPromptInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "POST",
+        path: `${MUGGLE_TEST_PREFIX}/projects/${data.projectId}/use-cases/${data.useCaseId}/prompt`,
+        body: { instruction: data.instruction }
+      };
+    }
+  }
+];
+var testCaseTools = [
+  {
+    name: "qa_test_case_list",
+    description: "List test cases for a project.",
+    inputSchema: TestCaseListInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "GET",
+        path: `${MUGGLE_TEST_PREFIX}/test-cases`,
+        queryParams: { projectId: data.projectId, page: data.page, pageSize: data.pageSize }
+      };
+    }
+  },
+  {
+    name: "qa_test_case_get",
+    description: "Get details of a specific test case.",
+    inputSchema: TestCaseGetInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "GET",
+        path: `${MUGGLE_TEST_PREFIX}/test-cases/${data.testCaseId}`
+      };
+    }
+  },
+  {
+    name: "qa_test_case_list_by_use_case",
+    description: "List test cases for a specific use case.",
+    inputSchema: TestCaseListByUseCaseInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "GET",
+        path: `${MUGGLE_TEST_PREFIX}/use-cases/${data.useCaseId}/test-cases`
+      };
+    }
+  },
+  {
+    name: "qa_test_case_generate_from_prompt",
+    description: "Generate test cases from a natural language prompt. Returns preview test cases.",
+    inputSchema: TestCaseGenerateFromPromptInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "POST",
+        path: `${MUGGLE_TEST_PREFIX}/projects/${data.projectId}/use-cases/${data.useCaseId}/test-cases/prompt/preview`,
+        body: { instruction: data.instruction }
+      };
+    }
+  },
+  {
+    name: "qa_test_case_create",
+    description: "Create a new test case for a use case.",
+    inputSchema: TestCaseCreateInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "POST",
+        path: `${MUGGLE_TEST_PREFIX}/test-cases`,
+        body: {
+          projectId: data.projectId,
+          useCaseId: data.useCaseId,
+          title: data.title,
+          description: data.description,
+          goal: data.goal,
+          precondition: data.precondition,
+          expectedResult: data.expectedResult,
+          url: data.url,
+          status: data.status || "DRAFT",
+          priority: data.priority || "MEDIUM",
+          tags: data.tags || [],
+          category: data.category || "Functional",
+          automated: data.automated ?? true
+        }
+      };
+    }
+  }
+];
+var testScriptTools = [
+  {
+    name: "qa_test_script_list",
+    description: "List test scripts for a project.",
+    inputSchema: TestScriptListInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "GET",
+        path: `${MUGGLE_TEST_PREFIX}/test-scripts`,
+        queryParams: { projectId: data.projectId, page: data.page, pageSize: data.pageSize }
+      };
+    }
+  },
+  {
+    name: "qa_test_script_get",
+    description: "Get details of a specific test script.",
+    inputSchema: TestScriptGetInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "GET",
+        path: `${MUGGLE_TEST_PREFIX}/test-scripts/${data.testScriptId}`
+      };
+    }
+  },
+  {
+    name: "qa_test_script_list_paginated",
+    description: "List test scripts with full pagination support.",
+    inputSchema: TestScriptListPaginatedInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "GET",
+        path: `${MUGGLE_TEST_PREFIX}/test-scripts/paginated`,
+        queryParams: { projectId: data.projectId, page: data.page, pageSize: data.pageSize }
+      };
+    }
+  }
+];
+var workflowTools = [
+  {
+    name: "qa_workflow_start_website_scan",
+    description: "Start a website scan workflow to discover use cases from a URL.",
+    inputSchema: WorkflowStartWebsiteScanInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "POST",
+        path: `${MUGGLE_TEST_PREFIX}/workflow/use-case/website-scan`,
+        body: {
+          projectId: data.projectId,
+          url: data.url,
+          description: data.description,
+          archiveUnapproved: data.archiveUnapproved,
+          ...data.workflowParams && { workflowParams: data.workflowParams }
+        },
+        timeoutMs: getWorkflowTimeoutMs()
+      };
+    }
+  },
+  {
+    name: "qa_workflow_list_website_scan_runtimes",
+    description: "List website scan workflow runtimes.",
+    inputSchema: WorkflowListRuntimesInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "GET",
+        path: `${MUGGLE_TEST_PREFIX}/workflow/use-case/website-scan/workflowRuntimes`,
+        queryParams: { projectId: data.projectId }
+      };
+    }
+  },
+  {
+    name: "qa_workflow_get_website_scan_latest_run",
+    description: "Get the latest run status for a website scan workflow runtime.",
+    inputSchema: WorkflowGetLatestRunInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "GET",
+        path: `${MUGGLE_TEST_PREFIX}/workflow/use-case/website-scan/${data.workflowRuntimeId}/run/latest`
+      };
+    }
+  },
+  {
+    name: "qa_workflow_start_test_case_detection",
+    description: "Start a test case detection workflow to generate test cases from use cases.",
+    inputSchema: WorkflowStartTestCaseDetectionInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "POST",
+        path: `${MUGGLE_TEST_PREFIX}/workflow/test-case/test-case-detection`,
+        body: {
+          projectId: data.projectId,
+          useCaseId: data.useCaseId,
+          name: data.name,
+          description: data.description,
+          url: data.url,
+          ...data.workflowParams && { workflowParams: data.workflowParams }
+        },
+        timeoutMs: getWorkflowTimeoutMs()
+      };
+    }
+  },
+  {
+    name: "qa_workflow_list_test_case_detection_runtimes",
+    description: "List test case detection workflow runtimes.",
+    inputSchema: WorkflowListRuntimesInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "GET",
+        path: `${MUGGLE_TEST_PREFIX}/workflow/test-case/test-case-detection/workflowRuntimes`,
+        queryParams: { projectId: data.projectId }
+      };
+    }
+  },
+  {
+    name: "qa_workflow_get_test_case_detection_latest_run",
+    description: "Get the latest run status for a test case detection workflow runtime.",
+    inputSchema: WorkflowGetLatestRunInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "GET",
+        path: `${MUGGLE_TEST_PREFIX}/workflow/test-case/test-case-detection/${data.workflowRuntimeId}/run/latest`
+      };
+    }
+  },
+  {
+    name: "qa_workflow_start_test_script_generation",
+    description: "Start a test script generation workflow.",
+    inputSchema: WorkflowStartTestScriptGenerationInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "POST",
+        path: `${MUGGLE_TEST_PREFIX}/workflow/test-script/test-script-generation`,
+        body: {
+          projectId: data.projectId,
+          testCaseId: data.testCaseId,
+          useCaseId: data.useCaseId,
+          name: data.name,
+          url: data.url,
+          goal: data.goal,
+          precondition: data.precondition,
+          instructions: data.instructions,
+          expectedResult: data.expectedResult,
+          ...data.workflowParams && { workflowParams: data.workflowParams }
+        },
+        timeoutMs: getWorkflowTimeoutMs()
+      };
+    }
+  },
+  {
+    name: "qa_workflow_get_test_script_generation_latest_run",
+    description: "Get the latest run status for a test script generation workflow runtime.",
+    inputSchema: WorkflowGetLatestRunInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "GET",
+        path: `${MUGGLE_TEST_PREFIX}/workflow/test-script/test-script-generation/${data.workflowRuntimeId}/run/latest`
+      };
+    }
+  },
+  {
+    name: "qa_workflow_get_latest_test_script_generation_runtime_by_test_case",
+    description: "Get the latest test script generation runtime for a specific test case.",
+    inputSchema: WorkflowGetLatestScriptGenByTestCaseInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "GET",
+        path: `${MUGGLE_TEST_PREFIX}/workflow/test-script/test-script-generation/testcases/${data.testCaseId}/runtime/latest`
+      };
+    }
+  },
+  {
+    name: "qa_workflow_start_test_script_replay",
+    description: "Start a test script replay workflow to execute a single test script.",
+    inputSchema: WorkflowStartTestScriptReplayInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "POST",
+        path: `${MUGGLE_TEST_PREFIX}/workflow/test-script/test-script-replay`,
+        body: {
+          projectId: data.projectId,
+          useCaseId: data.useCaseId,
+          testCaseId: data.testCaseId,
+          testScriptId: data.testScriptId,
+          name: data.name,
+          ...data.workflowParams && { workflowParams: data.workflowParams }
+        },
+        timeoutMs: getWorkflowTimeoutMs()
+      };
+    }
+  },
+  {
+    name: "qa_workflow_get_test_script_replay_latest_run",
+    description: "Get the latest run status for a test script replay workflow runtime.",
+    inputSchema: WorkflowGetLatestRunInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "GET",
+        path: `${MUGGLE_TEST_PREFIX}/workflow/test-script/test-script-replay/${data.workflowRuntimeId}/run/latest`
+      };
+    }
+  },
+  {
+    name: "qa_workflow_start_test_script_replay_bulk",
+    description: "Start a bulk test script replay workflow to execute multiple test scripts.",
+    inputSchema: WorkflowStartTestScriptReplayBulkInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "POST",
+        path: `${MUGGLE_TEST_PREFIX}/workflow/test-script/test-script-replay/bulk/workflowRuntimes`,
+        body: {
+          projectId: data.projectId,
+          name: data.name,
+          intervalSec: data.intervalSec,
+          useCaseId: data.useCaseId,
+          namePrefix: data.namePrefix,
+          limit: data.limit,
+          testCaseIds: data.testCaseIds,
+          repeatPerTestCase: data.repeatPerTestCase,
+          ...data.workflowParams && { workflowParams: data.workflowParams }
+        },
+        timeoutMs: getWorkflowTimeoutMs()
+      };
+    }
+  },
+  {
+    name: "qa_workflow_list_test_script_replay_bulk_runtimes",
+    description: "List bulk test script replay workflow runtimes.",
+    inputSchema: WorkflowListRuntimesInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "GET",
+        path: `${MUGGLE_TEST_PREFIX}/workflow/test-script/test-script-replay/bulk/workflowRuntimes`,
+        queryParams: { projectId: data.projectId }
+      };
+    }
+  },
+  {
+    name: "qa_workflow_get_test_script_replay_bulk_latest_run",
+    description: "Get the latest run status for a bulk test script replay workflow runtime.",
+    inputSchema: WorkflowGetLatestRunInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "GET",
+        path: `${MUGGLE_TEST_PREFIX}/workflow/test-script/test-script-replay/bulk/${data.workflowRuntimeId}/run/latest`
+      };
+    }
+  },
+  {
+    name: "qa_workflow_get_replay_bulk_run_batch_summary",
+    description: "Get the summary of a bulk replay run batch.",
+    inputSchema: WorkflowGetReplayBulkBatchSummaryInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "GET",
+        path: `${MUGGLE_TEST_PREFIX}/workflow/test-script/test-script-replay/bulk/run-batch/${data.runBatchId}/summary`
+      };
+    }
+  },
+  {
+    name: "qa_workflow_cancel_run",
+    description: "Cancel a running workflow run.",
+    inputSchema: WorkflowCancelRunInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "POST",
+        path: `${MUGGLE_TEST_PREFIX}/workflow/runs/${data.workflowRunId}/cancel`
+      };
+    }
+  },
+  {
+    name: "qa_workflow_cancel_runtime",
+    description: "Cancel a workflow runtime and all its runs.",
+    inputSchema: WorkflowCancelRuntimeInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "POST",
+        path: `${MUGGLE_TEST_PREFIX}/workflow/runtimes/${data.workflowRuntimeId}/cancel`
+      };
+    }
+  }
+];
+var reportTools = [
+  {
+    name: "qa_project_test_results_summary_get",
+    description: "Get a summary of test results for a project.",
+    inputSchema: ProjectTestResultsSummaryInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "GET",
+        path: `${MUGGLE_TEST_PREFIX}/projects/${data.projectId}/testResults`
+      };
+    }
+  },
+  {
+    name: "qa_project_test_scripts_summary_get",
+    description: "Get a summary of test scripts for a project.",
+    inputSchema: ProjectTestScriptsSummaryInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "GET",
+        path: `${MUGGLE_TEST_PREFIX}/projects/${data.projectId}/test-scripts/summary`
+      };
+    }
+  },
+  {
+    name: "qa_project_test_runs_summary_get",
+    description: "Get a summary of test runs for a project.",
+    inputSchema: ProjectTestRunsSummaryInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "GET",
+        path: `${MUGGLE_TEST_PREFIX}/projects/${data.projectId}/test-runs/summary`
+      };
+    }
+  },
+  {
+    name: "qa_report_stats_summary_get",
+    description: "Get report statistics summary for a project.",
+    inputSchema: ReportStatsSummaryInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "GET",
+        path: `${MUGGLE_TEST_PREFIX}/report/stats-summary`,
+        queryParams: { projectId: data.projectId }
+      };
+    }
+  },
+  {
+    name: "qa_report_cost_query",
+    description: "Query cost/usage data for a project over a date range.",
+    inputSchema: ReportCostQueryInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "POST",
+        path: `${MUGGLE_TEST_PREFIX}/report/cost/query`,
+        body: {
+          projectId: data.projectId,
+          startDateKey: data.startDateKey,
+          endDateKey: data.endDateKey,
+          filterType: data.filterType,
+          filterIds: data.filterIds
+        }
+      };
+    }
+  },
+  {
+    name: "qa_report_preferences_upsert",
+    description: "Update report delivery preferences for a project.",
+    inputSchema: ReportPreferencesUpsertInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "PUT",
+        path: `${MUGGLE_TEST_PREFIX}/report/preferences`,
+        body: {
+          projectId: data.projectId,
+          channels: data.channels,
+          emails: data.emails,
+          phones: data.phones,
+          webhookUrl: data.webhookUrl,
+          defaultExportFormat: data.defaultExportFormat
+        }
+      };
+    }
+  },
+  {
+    name: "qa_report_final_generate",
+    description: "Generate a final test report for a project.",
+    inputSchema: ReportFinalGenerateInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "POST",
+        path: `${MUGGLE_TEST_PREFIX}/report/final/generate`,
+        body: {
+          projectId: data.projectId,
+          exportFormat: data.exportFormat
+        },
+        timeoutMs: getWorkflowTimeoutMs()
+      };
+    }
+  }
+];
+var secretTools = [
+  {
+    name: "qa_secret_list",
+    description: "List all secrets for a project. Secret values are not returned for security.",
+    inputSchema: SecretListInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "GET",
+        path: `${MUGGLE_TEST_PREFIX}/secrets`,
+        queryParams: { projectId: data.projectId }
+      };
+    }
+  },
+  {
+    name: "qa_secret_create",
+    description: "Create a new secret (credential) for a project.",
+    inputSchema: SecretCreateInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "POST",
+        path: `${MUGGLE_TEST_PREFIX}/secrets`,
+        body: {
+          projectId: data.projectId,
+          secretName: data.name,
+          value: data.value,
+          description: data.description,
+          source: data.source
+        }
+      };
+    }
+  },
+  {
+    name: "qa_secret_get",
+    description: "Get details of a specific secret. The secret value is not returned for security.",
+    inputSchema: SecretGetInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "GET",
+        path: `${MUGGLE_TEST_PREFIX}/secrets/${data.secretId}`
+      };
+    }
+  },
+  {
+    name: "qa_secret_update",
+    description: "Update an existing secret.",
+    inputSchema: SecretUpdateInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      const body = {};
+      if (data.name !== void 0) body.name = data.name;
+      if (data.value !== void 0) body.value = data.value;
+      if (data.description !== void 0) body.description = data.description;
+      return {
+        method: "PUT",
+        path: `${MUGGLE_TEST_PREFIX}/secrets/${data.secretId}`,
+        body
+      };
+    }
+  },
+  {
+    name: "qa_secret_delete",
+    description: "Delete a secret from a project.",
+    inputSchema: SecretDeleteInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "DELETE",
+        path: `${MUGGLE_TEST_PREFIX}/secrets/${data.secretId}`
+      };
+    }
+  }
+];
+var prdFileTools = [
+  {
+    name: "qa_prd_file_upload",
+    description: "Upload a PRD file to a project. File content should be base64-encoded.",
+    inputSchema: PrdFileUploadInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "POST",
+        path: `${MUGGLE_TEST_PREFIX}/workflow/use-case/prd-file-upload`,
+        multipartFormData: {
+          fileFieldName: "file",
+          fileName: data.fileName,
+          contentType: data.contentType || "application/octet-stream",
+          fileBase64: data.contentBase64
+        }
+      };
+    }
+  },
+  {
+    name: "qa_prd_file_list_by_project",
+    description: "List all PRD files associated with a project.",
+    inputSchema: PrdFileListInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "GET",
+        path: `${MUGGLE_TEST_PREFIX}/projects/${data.projectId}/prd-files`
+      };
+    }
+  },
+  {
+    name: "qa_prd_file_delete",
+    description: "Delete a PRD file from a project.",
+    inputSchema: PrdFileDeleteInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "DELETE",
+        path: `${MUGGLE_TEST_PREFIX}/projects/${data.projectId}/prd-files/${data.prdFileId}`
+      };
+    }
+  },
+  {
+    name: "qa_workflow_start_prd_file_process",
+    description: "Start a PRD file processing workflow to extract use cases.",
+    inputSchema: PrdFileProcessStartInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "POST",
+        path: `${MUGGLE_TEST_PREFIX}/workflow/use-case/prd-file-process`,
+        body: {
+          projectId: data.projectId,
+          name: data.name,
+          description: data.description,
+          prdFilePath: data.prdFilePath,
+          originalFileName: data.originalFileName,
+          url: data.url,
+          contentChecksum: data.contentChecksum,
+          fileSize: data.fileSize
+        }
+      };
+    }
+  },
+  {
+    name: "qa_workflow_get_prd_file_process_latest_run",
+    description: "Get the latest run status of a PRD file processing workflow.",
+    inputSchema: PrdFileProcessLatestRunInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "GET",
+        path: `${MUGGLE_TEST_PREFIX}/workflow/use-case/prd-file-process/${data.workflowRuntimeId}/run/latest`
+      };
+    }
+  }
+];
+var walletTools = [
+  {
+    name: "qa_wallet_topup",
+    description: "Create a Stripe checkout session to purchase a token package.",
+    inputSchema: WalletTopUpInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "POST",
+        path: "/v1/protected/wallet/topup",
+        body: {
+          packageId: data.packageId,
+          checkoutSuccessCallback: data.checkoutSuccessCallback,
+          checkoutCancelCallback: data.checkoutCancelCallback
+        }
+      };
+    }
+  },
+  {
+    name: "qa_wallet_payment_method_create_setup_session",
+    description: "Create a Stripe setup session to add a payment method.",
+    inputSchema: WalletPaymentMethodCreateSetupSessionInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "POST",
+        path: "/v1/protected/wallet/payment-methods/setup",
+        body: {
+          checkoutSuccessCallback: data.checkoutSuccessCallback,
+          checkoutCancelCallback: data.checkoutCancelCallback
+        }
+      };
+    }
+  },
+  {
+    name: "qa_wallet_auto_topup_set_payment_method",
+    description: "Set the saved payment method used by wallet auto top-up.",
+    inputSchema: WalletAutoTopUpSetPaymentMethodInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "PUT",
+        path: "/v1/protected/wallet/auto-topup/payment-method",
+        body: { paymentMethodId: data.paymentMethodId }
+      };
+    }
+  },
+  {
+    name: "qa_wallet_payment_method_list",
+    description: "List saved payment methods.",
+    inputSchema: WalletPaymentMethodListInputSchema,
+    mapToUpstream: () => {
+      return {
+        method: "GET",
+        path: "/v1/protected/wallet/payment-methods"
+      };
+    }
+  },
+  {
+    name: "qa_wallet_auto_topup_update",
+    description: "Update wallet auto-topup settings.",
+    inputSchema: WalletAutoTopUpUpdateInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "PUT",
+        path: "/v1/protected/wallet/auto-topup",
+        body: {
+          enabled: data.enabled,
+          topUpTriggerTokenThreshold: data.topUpTriggerTokenThreshold,
+          packageId: data.packageId
+        }
+      };
+    }
+  }
+];
+var recommendationTools = [
+  {
+    name: "qa_recommend_schedule",
+    description: "Get recommendations for test scheduling based on project needs.",
+    inputSchema: RecommendScheduleInputSchema,
+    requiresAuth: false,
+    mapToUpstream: () => {
+      throw new Error("RECOMMENDATION_ONLY");
+    },
+    mapFromUpstream: () => {
+      return {
+        recommendations: [
+          {
+            title: "Nightly Regression Tests",
+            rationale: "Running tests every night catches regressions quickly.",
+            schedule: "0 2 * * *",
+            timezone: "UTC"
+          },
+          {
+            title: "On-Demand with Smoke Tests",
+            rationale: "Run smoke tests on every PR, full regression on merge.",
+            schedule: "Pull Request trigger + main branch merge"
+          },
+          {
+            title: "Continuous Monitoring",
+            rationale: "Run tests every 4 hours for production monitoring.",
+            schedule: "0 */4 * * *"
+          }
+        ]
+      };
+    },
+    localHandler: async () => {
+      return {
+        recommendations: [
+          {
+            title: "Nightly Regression Tests",
+            rationale: "Running tests every night catches regressions quickly.",
+            schedule: "0 2 * * *",
+            timezone: "UTC"
+          },
+          {
+            title: "On-Demand with Smoke Tests",
+            rationale: "Run smoke tests on every PR, full regression on merge.",
+            schedule: "Pull Request trigger + main branch merge"
+          },
+          {
+            title: "Continuous Monitoring",
+            rationale: "Run tests every 4 hours for production monitoring.",
+            schedule: "0 */4 * * *"
+          }
+        ]
+      };
+    }
+  },
+  {
+    name: "qa_recommend_cicd_setup",
+    description: "Get recommendations and templates for CI/CD integration.",
+    inputSchema: RecommendCicdSetupInputSchema,
+    requiresAuth: false,
+    mapToUpstream: () => {
+      throw new Error("RECOMMENDATION_ONLY");
+    },
+    localHandler: async (input) => {
+      const data = input;
+      const provider = data?.repositoryProvider || "github";
+      const recommendations = [];
+      if (provider === "github" || provider === "other") {
+        recommendations.push({
+          title: "GitHub Actions Integration",
+          rationale: "Native GitHub integration with minimal setup.",
+          steps: [
+            "Create .github/workflows/muggle-test.yml",
+            "Add MUGGLE_AI_API_KEY as a repository secret",
+            "Configure workflow trigger"
+          ]
+        });
+      }
+      if (provider === "azureDevOps" || provider === "other") {
+        recommendations.push({
+          title: "Azure DevOps Pipelines Integration",
+          rationale: "Native Azure DevOps integration with pipeline triggers.",
+          steps: [
+            "Create azure-pipelines.yml",
+            "Add MUGGLE_AI_API_KEY to variable group",
+            "Configure triggers"
+          ]
+        });
+      }
+      if (provider === "gitlab" || provider === "other") {
+        recommendations.push({
+          title: "GitLab CI Integration",
+          rationale: "Native GitLab CI integration with merge request pipelines.",
+          steps: [
+            "Add .gitlab-ci.yml",
+            "Add MUGGLE_AI_API_KEY as CI/CD variable",
+            "Configure pipeline rules"
+          ]
+        });
+      }
+      return { recommendations };
+    }
+  }
+];
+var API_KEY_PREFIX = "/v1/protected/api-keys";
+var apiKeyTools = [
+  {
+    name: "qa_auth_api_key_create",
+    description: "Create a new API key for the authenticated user. Requires existing authentication.",
+    inputSchema: ApiKeyCreateInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "POST",
+        path: API_KEY_PREFIX,
+        body: {
+          name: data.name || "MCP Gateway Key",
+          expiry: data.expiry || "90d"
+        }
+      };
+    },
+    mapFromUpstream: (response) => {
+      const data = response.data;
+      const maskedKey = `${data.prefix}...${data.lastFour}`;
+      const expiresAt = data.expiresAt ? new Date(data.expiresAt).toISOString() : "never";
+      return {
+        success: true,
+        message: "API key created.",
+        apiKey: {
+          id: data.id,
+          key: data.key,
+          hint: maskedKey,
+          name: data.name,
+          status: data.status,
+          createdAt: new Date(data.createdAt).toISOString(),
+          expiresAt
+        },
+        note: "The full API key is returned only once. Store it securely."
+      };
+    }
+  },
+  {
+    name: "qa_auth_api_key_list",
+    description: "List all API keys for the authenticated user. Shows key metadata but not the secret values.",
+    inputSchema: ApiKeyListInputSchema,
+    mapToUpstream: () => {
+      return {
+        method: "GET",
+        path: API_KEY_PREFIX
+      };
+    },
+    mapFromUpstream: (response) => {
+      const keys = response.data;
+      return {
+        success: true,
+        count: keys.length,
+        apiKeys: keys.map((key) => ({
+          id: key.id,
+          name: key.name,
+          status: key.status,
+          hint: `${key.prefix}...${key.lastFour}`,
+          createdAt: new Date(key.createdAt).toISOString(),
+          expiresAt: key.expiresAt ? new Date(key.expiresAt).toISOString() : "never",
+          revokedAt: key.revokedAt ? new Date(key.revokedAt).toISOString() : null
+        }))
+      };
+    }
+  },
+  {
+    name: "qa_auth_api_key_get",
+    description: "Get details of a specific API key by ID.",
+    inputSchema: ApiKeyGetInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "GET",
+        path: `${API_KEY_PREFIX}/${data.apiKeyId}`
+      };
+    },
+    mapFromUpstream: (response) => {
+      const key = response.data;
+      return {
+        success: true,
+        apiKey: {
+          id: key.id,
+          name: key.name,
+          status: key.status,
+          hint: `${key.prefix}...${key.lastFour}`,
+          createdAt: new Date(key.createdAt).toISOString(),
+          expiresAt: key.expiresAt ? new Date(key.expiresAt).toISOString() : "never",
+          revokedAt: key.revokedAt ? new Date(key.revokedAt).toISOString() : null
+        }
+      };
+    }
+  },
+  {
+    name: "qa_auth_api_key_revoke",
+    description: "Revoke an API key. The key will immediately stop working. Use qa_auth_api_key_list to find the key ID first.",
+    inputSchema: ApiKeyRevokeInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "DELETE",
+        path: `${API_KEY_PREFIX}/${data.apiKeyId}`
+      };
+    },
+    mapFromUpstream: () => {
+      return {
+        success: true,
+        message: "API key revoked successfully. It will no longer work for authentication."
+      };
+    }
+  }
+];
+var authTools = [
+  {
+    name: "qa_auth_status",
+    description: "Check current authentication status. Shows if you're logged in and when your session expires.",
+    inputSchema: EmptyInputSchema,
+    requiresAuth: false,
+    mapToUpstream: () => {
+      throw new Error("LOCAL_HANDLER_ONLY");
+    },
+    localHandler: async () => {
+      const authService = getAuthService();
+      const status = authService.getAuthStatus();
+      if (!status.authenticated) {
+        return {
+          authenticated: false,
+          message: "Not authenticated. Use qa_auth_login to authenticate."
+        };
+      }
+      return {
+        authenticated: true,
+        email: status.email,
+        userId: status.userId,
+        expiresAt: status.expiresAt,
+        isExpired: status.isExpired
+      };
+    }
+  },
+  {
+    name: "qa_auth_login",
+    description: "Start authentication with the Muggle Test service. Opens a browser-based login flow and waits for confirmation by default. If login is still pending after the wait timeout, use qa_auth_poll to finish authentication.",
+    inputSchema: AuthLoginInputSchema,
+    requiresAuth: false,
+    mapToUpstream: () => {
+      throw new Error("LOCAL_HANDLER_ONLY");
+    },
+    localHandler: async (input) => {
+      const data = input;
+      const authService = getAuthService();
+      const deviceCodeResponse = await authService.startDeviceCodeFlow();
+      const waitForCompletion = data.waitForCompletion ?? true;
+      if (!waitForCompletion) {
+        return {
+          status: "pending",
+          deviceCode: deviceCodeResponse.deviceCode,
+          userCode: deviceCodeResponse.userCode,
+          verificationUri: deviceCodeResponse.verificationUri,
+          browserOpened: deviceCodeResponse.browserOpened,
+          message: "Login started. Complete authentication in your browser, then call qa_auth_poll."
+        };
+      }
+      const pollResult = await authService.waitForDeviceCodeAuthorization({
+        deviceCode: deviceCodeResponse.deviceCode,
+        intervalSeconds: deviceCodeResponse.interval,
+        timeoutMs: data.timeoutMs
+      });
+      if (pollResult.status === "complete" /* Complete */) {
+        return {
+          status: "complete",
+          success: true,
+          email: pollResult.email,
+          message: "Login successful. You are now authenticated."
+        };
+      }
+      return {
+        status: pollResult.status,
+        message: pollResult.message
+      };
+    }
+  },
+  {
+    name: "qa_auth_poll",
+    description: "Poll for login completion after starting the login flow with qa_auth_login. Call this after the user completes authentication in their browser.",
+    inputSchema: AuthPollInputSchema,
+    requiresAuth: false,
+    mapToUpstream: () => {
+      throw new Error("LOCAL_HANDLER_ONLY");
+    },
+    localHandler: async (input) => {
+      const data = input;
+      const authService = getAuthService();
+      const deviceCode = data.deviceCode ?? authService.getPendingDeviceCode();
+      if (!deviceCode) {
+        return {
+          error: "NO_PENDING_LOGIN",
+          message: "No pending login found. Please start a new login with qa_auth_login."
+        };
+      }
+      const result = await authService.pollDeviceCode(deviceCode);
+      if (result.status === "complete" /* Complete */) {
+        return {
+          status: "complete",
+          success: true,
+          email: result.email,
+          message: "Login complete. You are now authenticated."
+        };
+      }
+      return {
+        status: result.status,
+        message: result.message
+      };
+    }
+  },
+  {
+    name: "qa_auth_logout",
+    description: "Log out and clear stored credentials.",
+    inputSchema: EmptyInputSchema,
+    requiresAuth: false,
+    mapToUpstream: () => {
+      throw new Error("LOCAL_HANDLER_ONLY");
+    },
+    localHandler: async () => {
+      const authService = getAuthService();
+      const result = authService.logout();
+      if (result) {
+        return { success: true, message: "Successfully logged out." };
+      }
+      return { success: false, message: "No active session to log out from." };
+    }
+  }
+];
+var allQaToolDefinitions = [
+  ...projectTools,
+  ...useCaseTools,
+  ...testCaseTools,
+  ...testScriptTools,
+  ...workflowTools,
+  ...reportTools,
+  ...secretTools,
+  ...prdFileTools,
+  ...walletTools,
+  ...recommendationTools,
+  ...apiKeyTools,
+  ...authTools
+];
+function getQaToolByName(name) {
+  return allQaToolDefinitions.find((tool) => tool.name === name);
+}
+function defaultResponseMapper(response) {
+  return response.data;
+}
+async function executeQaTool(toolName, input, correlationId) {
+  const logger5 = createChildLogger(correlationId);
+  const tool = getQaToolByName(toolName);
+  if (!tool) {
+    return {
+      content: JSON.stringify({ error: "NOT_FOUND", message: `Unknown tool: ${toolName}` }),
+      isError: true
+    };
+  }
+  try {
+    const validatedInput = tool.inputSchema.parse(input);
+    if (tool.localHandler) {
+      const result = await tool.localHandler(validatedInput);
+      return {
+        content: JSON.stringify(result, null, 2),
+        isError: false
+      };
+    }
+    const credentials = getCallerCredentials();
+    try {
+      const upstreamCall = tool.mapToUpstream(validatedInput);
+      const client = getPromptServiceClient();
+      const response = await client.execute(upstreamCall, credentials, correlationId);
+      const mapper = tool.mapFromUpstream || defaultResponseMapper;
+      const result = mapper(response, validatedInput);
+      return {
+        content: JSON.stringify(result, null, 2),
+        isError: false
+      };
+    } catch (error) {
+      if (error instanceof Error && error.message === "RECOMMENDATION_ONLY") {
+        const mapper = tool.mapFromUpstream || defaultResponseMapper;
+        const result = mapper({ statusCode: 200, data: {}, headers: {} }, validatedInput);
+        return {
+          content: JSON.stringify(result, null, 2),
+          isError: false
+        };
+      }
+      throw error;
+    }
+  } catch (error) {
+    if (error instanceof GatewayError) {
+      logger5.warn("Tool call failed with gateway error", {
+        tool: toolName,
+        code: error.code,
+        message: error.message
+      });
+      return {
+        content: JSON.stringify({ error: error.code, message: error.message }),
+        isError: true
+      };
+    }
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    logger5.error("Tool call failed", { tool: toolName, error: errorMessage });
+    return {
+      content: JSON.stringify({ error: "INTERNAL_ERROR", message: errorMessage }),
+      isError: true
+    };
+  }
+}
+
+// src/qa/index.ts
+function getQaTools() {
+  return allQaToolDefinitions.map((tool) => ({
+    name: tool.name,
+    description: tool.description,
+    inputSchema: tool.inputSchema,
+    requiresAuth: tool.requiresAuth !== false,
+    execute: async (params) => {
+      return executeQaTool(tool.name, params.input, params.correlationId);
+    }
+  }));
+}
+
+// src/local-qa/index.ts
+var local_qa_exports = {};
+__export(local_qa_exports, {
+  AuthLoginInputSchema: () => AuthLoginInputSchema2,
+  AuthPollInputSchema: () => AuthPollInputSchema2,
+  AuthService: () => AuthService,
+  CancelExecutionInputSchema: () => CancelExecutionInputSchema,
+  CleanupSessionsInputSchema: () => CleanupSessionsInputSchema,
+  CloudMappingEntityType: () => CloudMappingEntityType,
+  DeviceCodePollStatus: () => DeviceCodePollStatus,
+  EmptyInputSchema: () => EmptyInputSchema2,
+  ExecuteReplayInputSchema: () => ExecuteReplayInputSchema,
+  ExecuteTestGenerationInputSchema: () => ExecuteTestGenerationInputSchema,
+  ExecutionStatus: () => ExecutionStatus,
+  HealthStatus: () => HealthStatus,
+  ListSessionsInputSchema: () => ListSessionsInputSchema,
+  LocalRunStatus: () => LocalRunStatus,
+  LocalRunType: () => LocalRunType,
+  LocalTestScriptStatus: () => LocalTestScriptStatus,
+  LocalWorkflowFileEntityType: () => LocalWorkflowFileEntityType,
+  LocalWorkflowRunStatus: () => LocalWorkflowRunStatus,
+  PublishTestScriptInputSchema: () => PublishTestScriptInputSchema,
+  RunResultGetInputSchema: () => RunResultGetInputSchema,
+  RunResultListInputSchema: () => RunResultListInputSchema,
+  RunResultStorageService: () => RunResultStorageService,
+  SessionStatus: () => SessionStatus,
+  StorageService: () => StorageService,
+  TestCaseDetailsSchema: () => TestCaseDetailsSchema,
+  TestResultStatus: () => TestResultStatus,
+  TestScriptDetailsSchema: () => TestScriptDetailsSchema,
+  TestScriptGetInputSchema: () => TestScriptGetInputSchema2,
+  TestScriptListInputSchema: () => TestScriptListInputSchema2,
+  allLocalQaTools: () => allLocalQaTools,
+  cancelExecution: () => cancelExecution,
+  executeReplay: () => executeReplay,
+  executeTestGeneration: () => executeTestGeneration,
+  executeTool: () => executeTool,
+  getAuthService: () => getAuthService,
+  getLocalQaTools: () => getLocalQaTools,
+  getRunResultStorageService: () => getRunResultStorageService,
+  getStorageService: () => getStorageService,
+  getTool: () => getTool,
+  listActiveExecutions: () => listActiveExecutions,
+  resetAuthService: () => resetAuthService,
+  resetRunResultStorageService: () => resetRunResultStorageService,
+  resetStorageService: () => resetStorageService
+});
+var AuthLoginInputSchema2 = z.object({
+  waitForCompletion: z.boolean().optional().describe("Whether to wait for browser login completion before returning. Default: true"),
+  timeoutMs: z.number().int().positive().min(1e3).max(9e5).optional().describe("Maximum time to wait for login completion in milliseconds. Default: 120000")
+});
+var AuthPollInputSchema2 = z.object({
+  deviceCode: z.string().optional().describe("Device code from the login response. Optional if a login was recently started.")
+});
+var EmptyInputSchema2 = z.object({});
+var TestCaseDetailsSchema = z.object({
+  /** Cloud test case ID. */
+  id: z.string().min(1).describe("Cloud test case ID"),
+  /** Test case title. */
+  title: z.string().min(1).describe("Test case title"),
+  /** Test goal. */
+  goal: z.string().min(1).describe("Test goal - what the test should verify"),
+  /** Expected result. */
+  expectedResult: z.string().min(1).describe("Expected outcome after test execution"),
+  /** Preconditions (optional). */
+  precondition: z.string().optional().describe("Initial state/setup required before test execution"),
+  /** Step-by-step instructions (optional). */
+  instructions: z.string().optional().describe("Step-by-step instructions for the test"),
+  /** Original cloud URL (for reference, replaced by localUrl). */
+  url: z.string().url().optional().describe("Original cloud URL (replaced by localUrl during execution)")
+});
+var TestScriptDetailsSchema = z.object({
+  /** Cloud test script ID. */
+  id: z.string().min(1).describe("Cloud test script ID"),
+  /** Script name. */
+  name: z.string().min(1).describe("Test script name"),
+  /** Cloud test case ID this script belongs to. */
+  testCaseId: z.string().min(1).describe("Cloud test case ID this script was generated from"),
+  /** Action script steps. */
+  actionScript: z.array(z.unknown()).describe("Action script steps to replay"),
+  /** Original cloud URL (for reference, replaced by localUrl). */
+  url: z.string().url().optional().describe("Original cloud URL (replaced by localUrl during execution)")
+});
+var ExecuteTestGenerationInputSchema = z.object({
+  /** Test case details from qa_test_case_get. */
+  testCase: TestCaseDetailsSchema.describe("Test case details obtained from qa_test_case_get"),
+  /** Local URL to test against. */
+  localUrl: z.string().url().describe("Local URL to test against (e.g., http://localhost:3000)"),
+  /** Explicit approval to launch electron-app. */
+  approveElectronAppLaunch: z.boolean().describe("Set to true after the user explicitly approves launching electron-app"),
+  /** Optional timeout. */
+  timeoutMs: z.number().int().positive().optional().describe("Timeout in milliseconds (default: 300000 = 5 min)")
+});
+var ExecuteReplayInputSchema = z.object({
+  /** Test script details from qa_test_script_get. */
+  testScript: TestScriptDetailsSchema.describe("Test script details obtained from qa_test_script_get"),
+  /** Local URL to test against. */
+  localUrl: z.string().url().describe("Local URL to test against (e.g., http://localhost:3000)"),
+  /** Explicit approval to launch electron-app. */
+  approveElectronAppLaunch: z.boolean().describe("Set to true after the user explicitly approves launching electron-app"),
+  /** Optional timeout. */
+  timeoutMs: z.number().int().positive().optional().describe("Timeout in milliseconds (default: 180000 = 3 min)")
+});
+var CancelExecutionInputSchema = z.object({
+  runId: z.string().min(1).describe("Run ID to cancel")
+});
+var RunResultListInputSchema = z.object({
+  cloudTestCaseId: z.string().optional().describe("Optional cloud test case ID to filter by"),
+  limit: z.number().int().positive().optional().describe("Maximum results to return (default: 20)")
+});
+var RunResultGetInputSchema = z.object({
+  runId: z.string().min(1).describe("Run result ID to retrieve")
+});
+var TestScriptListInputSchema2 = z.object({
+  cloudTestCaseId: z.string().optional().describe("Optional cloud test case ID to filter by")
+});
+var TestScriptGetInputSchema2 = z.object({
+  testScriptId: z.string().min(1).describe("Test script ID to retrieve")
+});
+var PublishTestScriptInputSchema = z.object({
+  runId: z.string().min(1).describe("Local run result ID from muggle_execute_test_generation"),
+  cloudTestCaseId: z.string().min(1).describe("Cloud test case ID to publish the script under")
+});
+var ListSessionsInputSchema = z.object({
+  limit: z.number().int().positive().optional().describe("Maximum number of sessions to return. Defaults to 10.")
+});
+var CleanupSessionsInputSchema = z.object({
+  max_age_days: z.number().int().min(0).optional().describe("Maximum age of sessions to keep (in days). Sessions older than this will be deleted. Defaults to 30.")
+});
+
+// src/local-qa/tools/tool-registry.ts
+function createChildLogger2(correlationId) {
+  const logger5 = getLogger();
+  return {
+    info: (msg, meta) => logger5.info(msg, { ...meta, correlationId }),
+    error: (msg, meta) => logger5.error(msg, { ...meta, correlationId }),
+    warn: (msg, meta) => logger5.warn(msg, { ...meta, correlationId }),
+    debug: (msg, meta) => logger5.debug(msg, { ...meta, correlationId })
+  };
+}
+var checkStatusTool = {
+  name: "muggle_check_status",
+  description: "Check the status of Muggle Test Local. This verifies the connection to web-service and shows current session information.",
+  inputSchema: EmptyInputSchema2,
+  execute: async (ctx) => {
+    const logger5 = createChildLogger2(ctx.correlationId);
+    logger5.info("Executing muggle_check_status");
+    const authService = getAuthService();
+    const storageService = getStorageService();
+    const authStatus = authService.getAuthStatus();
+    const content = [
+      "## Muggle Test Local Status",
+      "",
+      `**Data Directory:** ${storageService.getDataDir()}`,
+      `**Sessions Directory:** ${storageService.getSessionsDir()}`,
+      "",
+      "### Authentication",
+      `**Authenticated:** ${authStatus.authenticated ? "Yes" : "No"}`,
+      authStatus.email ? `**Email:** ${authStatus.email}` : "",
+      authStatus.expiresAt ? `**Expires:** ${authStatus.expiresAt}` : ""
+    ].filter(Boolean).join("\n");
+    return { content, isError: false };
+  }
+};
+var listSessionsTool = {
+  name: "muggle_list_sessions",
+  description: "List all stored testing sessions. Shows session IDs, status, and metadata for each session.",
+  inputSchema: ListSessionsInputSchema,
+  execute: async (ctx) => {
+    const logger5 = createChildLogger2(ctx.correlationId);
+    logger5.info("Executing muggle_list_sessions");
+    const input = ListSessionsInputSchema.parse(ctx.input);
+    const storageService = getStorageService();
+    const sessions = storageService.listSessionsWithMetadata();
+    const limit = input.limit ?? 10;
+    const limited = sessions.slice(0, limit);
+    if (limited.length === 0) {
+      return { content: "No sessions found.", isError: false, data: { sessions: [] } };
+    }
+    const lines = limited.map((s) => {
+      return `- **${s.sessionId}** - ${s.status} - ${s.targetUrl} (${s.stepsCount ?? 0} steps)`;
+    });
+    const content = [
+      "## Sessions",
+      "",
+      ...lines,
+      "",
+      sessions.length > limit ? `Showing ${limit} of ${sessions.length} sessions.` : ""
+    ].filter(Boolean).join("\n");
+    return { content, isError: false, data: { sessions: limited } };
+  }
+};
+var runResultListTool = {
+  name: "muggle_run_result_list",
+  description: "List run results (test generation and replay history), optionally filtered by cloud test case ID.",
+  inputSchema: RunResultListInputSchema,
+  execute: async (ctx) => {
+    const logger5 = createChildLogger2(ctx.correlationId);
+    logger5.info("Executing muggle_run_result_list");
+    const input = RunResultListInputSchema.parse(ctx.input);
+    const storage = getRunResultStorageService();
+    let results = storage.listRunResults();
+    if (input.cloudTestCaseId) {
+      results = results.filter((r) => r.cloudTestCaseId === input.cloudTestCaseId);
+    }
+    const limit = input.limit ?? 20;
+    results = results.slice(0, limit);
+    if (results.length === 0) {
+      return { content: "No run results found.", isError: false, data: { results: [] } };
+    }
+    const lines = results.map((r) => {
+      return `- **${r.id}** - ${r.runType} - ${r.status} (${r.executionTimeMs ?? 0}ms)`;
+    });
+    const content = ["## Run Results", "", ...lines].join("\n");
+    return { content, isError: false, data: { results } };
+  }
+};
+var runResultGetTool = {
+  name: "muggle_run_result_get",
+  description: "Get detailed information about a run result including screenshots and action script output.",
+  inputSchema: RunResultGetInputSchema,
+  execute: async (ctx) => {
+    const logger5 = createChildLogger2(ctx.correlationId);
+    logger5.info("Executing muggle_run_result_get");
+    const input = RunResultGetInputSchema.parse(ctx.input);
+    const storage = getRunResultStorageService();
+    const result = storage.getRunResult(input.runId);
+    if (!result) {
+      return { content: `Run result not found: ${input.runId}`, isError: true };
+    }
+    const content = [
+      "## Run Result Details",
+      "",
+      `**ID:** ${result.id}`,
+      `**Type:** ${result.runType}`,
+      `**Status:** ${result.status}`,
+      `**Cloud Test Case:** ${result.cloudTestCaseId}`,
+      `**Duration:** ${result.executionTimeMs ?? 0}ms`,
+      result.errorMessage ? `**Error:** ${result.errorMessage}` : ""
+    ].filter(Boolean).join("\n");
+    return { content, isError: false, data: result };
+  }
+};
+var testScriptListTool = {
+  name: "muggle_test_script_list",
+  description: "List locally generated test scripts, optionally filtered by cloud test case ID.",
+  inputSchema: TestScriptListInputSchema2,
+  execute: async (ctx) => {
+    const logger5 = createChildLogger2(ctx.correlationId);
+    logger5.info("Executing muggle_test_script_list");
+    const input = TestScriptListInputSchema2.parse(ctx.input);
+    const storage = getRunResultStorageService();
+    let scripts = storage.listTestScripts();
+    if (input.cloudTestCaseId) {
+      scripts = scripts.filter((s) => s.cloudTestCaseId === input.cloudTestCaseId);
+    }
+    if (scripts.length === 0) {
+      return { content: "No test scripts found.", isError: false, data: { testScripts: [] } };
+    }
+    const lines = scripts.map((ts) => `- **${ts.name}** (${ts.id}) - ${ts.status}`);
+    const content = ["## Test Scripts", "", ...lines].join("\n");
+    return { content, isError: false, data: { testScripts: scripts } };
+  }
+};
+var testScriptGetTool = {
+  name: "muggle_test_script_get",
+  description: "Get details of a locally generated test script including action script steps.",
+  inputSchema: TestScriptGetInputSchema2,
+  execute: async (ctx) => {
+    const logger5 = createChildLogger2(ctx.correlationId);
+    logger5.info("Executing muggle_test_script_get");
+    const input = TestScriptGetInputSchema2.parse(ctx.input);
+    const storage = getRunResultStorageService();
+    const testScript = storage.getTestScript(input.testScriptId);
+    if (!testScript) {
+      return { content: `Test script not found: ${input.testScriptId}`, isError: true };
+    }
+    const content = [
+      "## Test Script Details",
+      "",
+      `**ID:** ${testScript.id}`,
+      `**Name:** ${testScript.name}`,
+      `**URL:** ${testScript.url}`,
+      `**Status:** ${testScript.status}`,
+      testScript.goal ? `**Goal:** ${testScript.goal}` : "",
+      testScript.actionScript ? `**Steps:** ${testScript.actionScript.length}` : ""
+    ].filter(Boolean).join("\n");
+    return { content, isError: false, data: testScript };
+  }
+};
+var executeTestGenerationTool = {
+  name: "muggle_execute_test_generation",
+  description: "Execute test script generation for a test case. First call qa_test_case_get to get test case details, then pass them here along with the localhost URL. Requires explicit approval before launching electron-app in explore mode.",
+  inputSchema: ExecuteTestGenerationInputSchema,
+  execute: async (ctx) => {
+    const logger5 = createChildLogger2(ctx.correlationId);
+    logger5.info("Executing muggle_execute_test_generation");
+    const input = ExecuteTestGenerationInputSchema.parse(ctx.input);
+    if (!input.approveElectronAppLaunch) {
+      return {
+        content: [
+          "## Electron App Launch Required",
+          "",
+          "This tool will launch the electron-app to generate a test script.",
+          "Please set `approveElectronAppLaunch: true` to proceed.",
+          "",
+          `**Test Case:** ${input.testCase.title}`,
+          `**Local URL:** ${input.localUrl}`,
+          "",
+          "**Note:** The electron-app will open a browser window and navigate to your test URL."
+        ].join("\n"),
+        isError: false,
+        data: { requiresApproval: true }
+      };
+    }
+    try {
+      const result = await executeTestGeneration({
+        testCase: input.testCase,
+        localUrl: input.localUrl,
+        timeoutMs: input.timeoutMs
+      });
+      const content = [
+        "## Test Generation " + (result.status === "passed" ? "Successful" : "Failed"),
+        "",
+        `**Run ID:** ${result.id}`,
+        `**Test Script ID:** ${result.testScriptId}`,
+        `**Status:** ${result.status}`,
+        `**Duration:** ${result.executionTimeMs}ms`,
+        result.errorMessage ? `**Error:** ${result.errorMessage}` : ""
+      ].filter(Boolean).join("\n");
+      return {
+        content,
+        isError: result.status !== "passed",
+        data: result
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      logger5.error("Test generation failed", { error: errorMessage });
+      return { content: `Test generation failed: ${errorMessage}`, isError: true };
+    }
+  }
+};
+var executeReplayTool = {
+  name: "muggle_execute_replay",
+  description: "Execute test script replay. First call qa_test_script_get to get test script details (including actionScript), then pass them here along with the localhost URL. Requires explicit approval before launching electron-app in engine mode.",
+  inputSchema: ExecuteReplayInputSchema,
+  execute: async (ctx) => {
+    const logger5 = createChildLogger2(ctx.correlationId);
+    logger5.info("Executing muggle_execute_replay");
+    const input = ExecuteReplayInputSchema.parse(ctx.input);
+    if (!input.approveElectronAppLaunch) {
+      return {
+        content: [
+          "## Electron App Launch Required",
+          "",
+          "This tool will launch the electron-app to replay a test script.",
+          "Please set `approveElectronAppLaunch: true` to proceed.",
+          "",
+          `**Test Script:** ${input.testScript.name}`,
+          `**Local URL:** ${input.localUrl}`,
+          `**Steps:** ${input.testScript.actionScript.length}`,
+          "",
+          "**Note:** The electron-app will open a browser window and execute the test steps."
+        ].join("\n"),
+        isError: false,
+        data: { requiresApproval: true }
+      };
+    }
+    try {
+      const result = await executeReplay({
+        testScript: input.testScript,
+        localUrl: input.localUrl,
+        timeoutMs: input.timeoutMs
+      });
+      const content = [
+        "## Test Replay " + (result.status === "passed" ? "Successful" : "Failed"),
+        "",
+        `**Run ID:** ${result.id}`,
+        `**Test Script ID:** ${result.testScriptId}`,
+        `**Status:** ${result.status}`,
+        `**Duration:** ${result.executionTimeMs}ms`,
+        result.errorMessage ? `**Error:** ${result.errorMessage}` : ""
+      ].filter(Boolean).join("\n");
+      return {
+        content,
+        isError: result.status !== "passed",
+        data: result
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      logger5.error("Test replay failed", { error: errorMessage });
+      return { content: `Test replay failed: ${errorMessage}`, isError: true };
+    }
+  }
+};
+var cancelExecutionTool = {
+  name: "muggle_cancel_execution",
+  description: "Cancel an active test generation or replay execution.",
+  inputSchema: CancelExecutionInputSchema,
+  execute: async (ctx) => {
+    const logger5 = createChildLogger2(ctx.correlationId);
+    logger5.info("Executing muggle_cancel_execution");
+    const input = CancelExecutionInputSchema.parse(ctx.input);
+    const cancelled = cancelExecution({ runId: input.runId });
+    if (cancelled) {
+      return { content: `Execution cancelled: ${input.runId}`, isError: false };
+    }
+    return { content: `No active execution found with ID: ${input.runId}`, isError: true };
+  }
+};
+var publishTestScriptTool = {
+  name: "muggle_publish_test_script",
+  description: "Publish a locally generated test script to the cloud. Uses the run ID from muggle_execute_test_generation to find the script and uploads it to the specified cloud test case.",
+  inputSchema: PublishTestScriptInputSchema,
+  execute: async (ctx) => {
+    const logger5 = createChildLogger2(ctx.correlationId);
+    logger5.info("Executing muggle_publish_test_script");
+    const input = PublishTestScriptInputSchema.parse(ctx.input);
+    const storage = getRunResultStorageService();
+    const runResult = storage.getRunResult(input.runId);
+    if (!runResult) {
+      return { content: `Run result not found: ${input.runId}`, isError: true };
+    }
+    if (!runResult.testScriptId) {
+      return { content: `Run result ${input.runId} does not have an associated test script`, isError: true };
+    }
+    const testScript = storage.getTestScript(runResult.testScriptId);
+    if (!testScript) {
+      return { content: `Test script not found: ${runResult.testScriptId}`, isError: true };
+    }
+    return {
+      content: [
+        "## Test Script Publishing",
+        "",
+        "Publishing test scripts to cloud is not yet implemented.",
+        "",
+        `**Run ID:** ${input.runId}`,
+        `**Test Script ID:** ${runResult.testScriptId}`,
+        `**Target Cloud Test Case:** ${input.cloudTestCaseId}`
+      ].join("\n"),
+      isError: true
+    };
+  }
+};
+var allLocalQaTools = [
+  // Status tools
+  checkStatusTool,
+  listSessionsTool,
+  // Run result tools
+  runResultListTool,
+  runResultGetTool,
+  // Test script tools (read-only)
+  testScriptListTool,
+  testScriptGetTool,
+  // Execution tools
+  executeTestGenerationTool,
+  executeReplayTool,
+  cancelExecutionTool,
+  // Publishing tools
+  publishTestScriptTool
+];
+var toolMap = new Map(
+  allLocalQaTools.map((tool) => [tool.name, tool])
+);
+function getTool(name) {
+  return toolMap.get(name);
+}
+async function executeTool(name, input, correlationId) {
+  const tool = getTool(name);
+  if (!tool) {
+    return {
+      content: `Unknown tool: ${name}. Available tools: ${allLocalQaTools.map((t) => t.name).join(", ")}`,
+      isError: true
+    };
+  }
+  return tool.execute({ input, correlationId });
+}
+
+// src/local-qa/index.ts
+function getLocalQaTools() {
+  return allLocalQaTools.map((tool) => ({
+    name: tool.name,
+    description: tool.description,
+    inputSchema: tool.inputSchema,
+    requiresAuth: !isLocalOnlyTool(tool.name),
+    execute: async (params) => {
+      const result = await tool.execute({
+        input: params.input,
+        correlationId: params.correlationId
+      });
+      return {
+        content: result.content,
+        isError: result.isError,
+        data: result.data
+      };
+    }
+  }));
+}
+function isLocalOnlyTool(toolName) {
+  const localOnlyTools = [
+    // Status and session tools (no auth needed)
+    "muggle_check_status",
+    "muggle_list_sessions",
+    // Run result and test script viewing (local storage only)
+    "muggle_run_result_list",
+    "muggle_run_result_get",
+    "muggle_test_script_list",
+    "muggle_test_script_get"
+  ];
+  return localOnlyTools.includes(toolName);
+}
+
+export { __export, __require, createApiKeyWithToken, createChildLogger, createUnifiedMcpServer, deleteCredentials, getAuthStatus, getBundledElectronAppVersion, getCallerCredentials, getConfig, getCredentialsFilePath, getDataDir, getDownloadBaseUrl, getElectronAppChecksums, getElectronAppDir, getElectronAppVersion, getElectronAppVersionSource, getLocalQaTools, getLogger, getQaTools, getValidCredentials, isCredentialsExpired, isElectronAppInstalled, loadCredentials, local_qa_exports, openBrowserUrl, performLogin, performLogout, pollDeviceCode, qa_exports, registerTools, resetConfig, resetLogger, saveCredentials, server_exports, startDeviceCodeFlow, startStdioServer, toolRequiresAuth };
+//# sourceMappingURL=chunk-RXCZWOOD.js.map
+//# sourceMappingURL=chunk-RXCZWOOD.js.map