Set up comprehensive frontend testing infrastructure

- Install Jest for unit testing with React Testing Library
- Install Playwright for end-to-end testing
- Configure Jest with proper TypeScript support and module mapping
- Create test setup files and utilities for both unit and e2e tests

Components:
* Jest configuration with coverage thresholds
* Playwright configuration with browser automation
* Unit tests for LoginForm, AuthContext, and useSocketIO hook
* E2E tests for authentication, dashboard, and agents workflows
* GitHub Actions workflow for automated testing
* Mock data and API utilities for consistent testing
* Test documentation with best practices

Testing features:
- Unit tests with 70% coverage threshold
- E2E tests with API mocking and user journey testing
- CI/CD integration for automated test runs
- Cross-browser testing support with Playwright
- Authentication system testing end-to-end

🚀 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

frontend/node_modules/jest-leak-detector/build/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+declare class LeakDetector {
+  private _isReferenceBeingHeld;
+  private readonly _finalizationRegistry?;
+  constructor(value: unknown);
+  isLeaking(): Promise<boolean>;
+  private _runGarbageCollector;
+}
+export default LeakDetector;
+
+export {};

frontend/node_modules/jest-leak-detector/build/index.js

@@ -0,0 +1,119 @@
+/*!
+ * /**
+ *  * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *  *
+ *  * This source code is licensed under the MIT license found in the
+ *  * LICENSE file in the root directory of this source tree.
+ *  * /
+ */
+/******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+var __webpack_exports__ = {};
+// This entry needs to be wrapped in an IIFE because it uses a non-standard name for the exports (exports).
+(() => {
+var exports = __webpack_exports__;
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports["default"] = void 0;
+function _util() {
+  const data = require("util");
+  _util = function () {
+    return data;
+  };
+  return data;
+}
+function _v() {
+  const data = require("v8");
+  _v = function () {
+    return data;
+  };
+  return data;
+}
+function _vm() {
+  const data = require("vm");
+  _vm = function () {
+    return data;
+  };
+  return data;
+}
+function _getType() {
+  const data = require("@jest/get-type");
+  _getType = function () {
+    return data;
+  };
+  return data;
+}
+function _prettyFormat() {
+  const data = require("pretty-format");
+  _prettyFormat = function () {
+    return data;
+  };
+  return data;
+}
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/// <reference lib="es2021.WeakRef" />
+
+const tick = (0, _util().promisify)(setImmediate);
+class LeakDetector {
+  _isReferenceBeingHeld;
+  _finalizationRegistry;
+  constructor(value) {
+    if ((0, _getType().isPrimitive)(value)) {
+      throw new TypeError(['Primitives cannot leak memory.', `You passed a ${typeof value}: <${(0, _prettyFormat().format)(value)}>`].join(' '));
+    }
+
+    // When `_finalizationRegistry` is GCed the callback we set will no longer be called,
+    this._finalizationRegistry = new FinalizationRegistry(() => {
+      this._isReferenceBeingHeld = false;
+    });
+    this._finalizationRegistry.register(value, undefined);
+    this._isReferenceBeingHeld = true;
+
+    // Ensure value is not leaked by the closure created by the "weak" callback.
+    value = null;
+  }
+  async isLeaking() {
+    this._runGarbageCollector();
+
+    // wait some ticks to allow GC to run properly, see https://github.com/nodejs/node/issues/34636#issuecomment-669366235
+    for (let i = 0; i < 10; i++) {
+      await tick();
+    }
+    if (this._isReferenceBeingHeld) {
+      // triggering a heap snapshot is more aggressive than just `global.gc()`,
+      // but it's also quite slow, so only do it if we still think we're leaking.
+      // https://github.com/nodejs/node/pull/48510#issuecomment-1719289759
+      (0, _v().getHeapSnapshot)();
+      for (let i = 0; i < 10; i++) {
+        await tick();
+      }
+    }
+    return this._isReferenceBeingHeld;
+  }
+  _runGarbageCollector() {
+    const isGarbageCollectorHidden = globalThis.gc == null;
+
+    // GC is usually hidden, so we have to expose it before running.
+    (0, _v().setFlagsFromString)('--expose-gc');
+    (0, _vm().runInNewContext)('gc')();
+
+    // The GC was not initially exposed, so let's hide it again.
+    if (isGarbageCollectorHidden) {
+      (0, _v().setFlagsFromString)('--no-expose-gc');
+    }
+  }
+}
+exports["default"] = LeakDetector;
+})();
+
+module.exports = __webpack_exports__;
+/******/ })()
+;

frontend/node_modules/jest-leak-detector/build/index.mjs

@@ -0,0 +1,3 @@
+import cjsModule from './index.js';
+
+export default cjsModule.default;