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/bs-logger/dist/logger/context.d.ts

@@ -0,0 +1,16 @@
+declare enum LogContexts {
+    application = "application",
+    hostname = "hostname",
+    logLevel = "logLevel",
+    namespace = "namespace",
+    package = "package"
+}
+interface LogContext {
+    [key: string]: any;
+    [LogContexts.application]?: string;
+    [LogContexts.hostname]?: string;
+    [LogContexts.logLevel]?: number;
+    [LogContexts.namespace]?: string;
+    [LogContexts.package]?: string;
+}
+export { LogContext, LogContexts };

frontend/node_modules/bs-logger/dist/logger/context.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var LogContexts;
+(function (LogContexts) {
+    LogContexts["application"] = "application";
+    LogContexts["hostname"] = "hostname";
+    LogContexts["logLevel"] = "logLevel";
+    LogContexts["namespace"] = "namespace";
+    LogContexts["package"] = "package";
+})(LogContexts || (LogContexts = {}));
+exports.LogContexts = LogContexts;

frontend/node_modules/bs-logger/dist/logger/index.d.ts

@@ -0,0 +1,37 @@
+import { LogContext } from './context';
+import { LogMessageTranslator } from './message';
+import { LogTarget } from './target';
+interface LogMethod {
+    (message: string, ...args: any[]): void;
+    (context: LogContext, message: string, ...args: any[]): void;
+    isEmptyFunction?: boolean;
+}
+interface LogChildMethod {
+    (context: LogContext): Logger;
+    (translate: LogMessageTranslator): Logger;
+}
+interface LogWrapMethod {
+    <F extends (...args: any[]) => any>(func: F): F;
+    <F extends (...args: any[]) => any>(message: string, func: F): F;
+    <F extends (...args: any[]) => any>(context: LogContext, message: string, func: F): F;
+    <F extends (...args: any[]) => any>(level: number, message: string, func: F): F;
+}
+interface Logger extends LogMethod {
+    trace: LogMethod;
+    debug: LogMethod;
+    info: LogMethod;
+    warn: LogMethod;
+    error: LogMethod;
+    fatal: LogMethod;
+    child: LogChildMethod;
+    wrap: LogWrapMethod;
+}
+declare const resetSequence: (next?: number) => void;
+declare const lastSequenceNumber: () => number;
+interface CreateLoggerOptions {
+    context?: LogContext;
+    translate?: LogMessageTranslator;
+    targets?: string | LogTarget[];
+}
+declare const createLogger: ({ context: baseContext, targets: logTargets, translate: logTranslator, }?: CreateLoggerOptions) => Logger;
+export { createLogger, lastSequenceNumber, Logger, LogMethod, resetSequence, CreateLoggerOptions };

frontend/node_modules/bs-logger/dist/logger/index.js

@@ -0,0 +1,164 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spread = (this && this.__spread) || function () {
+    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
+    return ar;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var util_1 = require("util");
+var context_1 = require("./context");
+var level_1 = require("./level");
+var target_1 = require("./target");
+var lastSeqNumber = 0;
+var resetSequence = function (next) {
+    if (next === void 0) { next = 1; }
+    lastSeqNumber = next - 1;
+};
+exports.resetSequence = resetSequence;
+var lastSequenceNumber = function () { return lastSeqNumber; };
+exports.lastSequenceNumber = lastSequenceNumber;
+var createEmptyFunction = function () {
+    return Object.defineProperty(function emptyFunction() { }, 'isEmptyFunction', { value: true });
+};
+var createEmptyLogger = function () {
+    var log = createEmptyFunction();
+    log.child = function () { return createEmptyLogger(); };
+    log.wrap = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return args.pop();
+    };
+    level_1.LogLevelNames.forEach(function (name) {
+        log[name] = log;
+    });
+    return log;
+};
+var createLogger = function (_a) {
+    var _b = _a === void 0 ? {} : _a, _c = _b.context, baseContext = _c === void 0 ? {} : _c, _d = _b.targets, logTargets = _d === void 0 ? target_1.DEFAULT_LOG_TARGET : _d, logTranslator = _b.translate;
+    var targets = typeof logTargets === 'string' ? target_1.parseLogTargets(logTargets) : logTargets;
+    if (targets.length === 0) {
+        return createEmptyLogger();
+    }
+    var log = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var time = Date.now();
+        var sequence = ++lastSeqNumber;
+        var context;
+        if (typeof args[0] === 'string') {
+            context = __assign({}, baseContext);
+        }
+        else {
+            context = __assign({}, baseContext, args.shift());
+        }
+        var msg = args.shift();
+        var logLevel = context[context_1.LogContexts.logLevel];
+        var destTargets = logLevel == null ? targets : targets.filter(function (t) { return logLevel >= t.minLevel; });
+        if (destTargets.length === 0) {
+            return;
+        }
+        var message = util_1.format.apply(void 0, __spread([msg], args));
+        var logMessage = {
+            context: context,
+            time: time,
+            sequence: sequence,
+            message: message,
+        };
+        if (logTranslator) {
+            logMessage = logTranslator(logMessage);
+        }
+        destTargets.forEach(function (t) { return t.stream.write(t.format(logMessage) + "\n"); });
+    };
+    log.child = function (ctxOrTranslator) {
+        var isTranslator = typeof ctxOrTranslator === 'function';
+        var childContext = isTranslator ? __assign({}, baseContext) : __assign({}, baseContext, ctxOrTranslator);
+        var translate;
+        if (isTranslator) {
+            if (logTranslator) {
+                translate = function (msg) { return ctxOrTranslator(logTranslator(msg)); };
+            }
+            else {
+                translate = ctxOrTranslator;
+            }
+        }
+        else {
+            translate = logTranslator;
+        }
+        return createLogger({ context: childContext, targets: targets, translate: translate });
+    };
+    log.wrap = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var _a;
+        var _b = __read(Array(3 - args.length).concat(args), 3), ctx = _b[0], msg = _b[1], func = _b[2];
+        var context = typeof ctx === 'number' ? __assign({}, baseContext, (_a = {}, _a[context_1.LogContexts.logLevel] = ctx, _a)) : __assign({}, baseContext, ctx);
+        var logLevel = context[context_1.LogContexts.logLevel];
+        if (typeof logLevel === 'number' && targets.every(function (t) { return t.minLevel > logLevel; })) {
+            return func;
+        }
+        var message = msg == null ? "calling " + (func.name || '[anonymous]') + "()" : msg;
+        return function wrapped() {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            log(__assign({ call: { args: args } }, context), message);
+            return func.apply(this, args);
+        };
+    };
+    level_1.LogLevelNames.forEach(function (name) {
+        var _a;
+        var level = level_1.LogLevels[name];
+        var extraContext = (_a = {}, _a[context_1.LogContexts.logLevel] = level, _a);
+        log[name] = function (ctxOrMsg) {
+            var args = [];
+            for (var _i = 1; _i < arguments.length; _i++) {
+                args[_i - 1] = arguments[_i];
+            }
+            if (targets.length === 0 || targets.every(function (t) { return t.minLevel > level; })) {
+                log[name] = createEmptyFunction();
+                return;
+            }
+            if (typeof ctxOrMsg === 'string') {
+                log.apply(void 0, __spread([extraContext, ctxOrMsg], args));
+            }
+            else {
+                log.apply(void 0, __spread([__assign({}, ctxOrMsg, extraContext)], args));
+            }
+        };
+    });
+    return log;
+};
+exports.createLogger = createLogger;

frontend/node_modules/bs-logger/dist/logger/level.d.ts

@@ -0,0 +1,25 @@
+declare const LogLevels: {
+    trace: number;
+    debug: number;
+    info: number;
+    warn: number;
+    error: number;
+    fatal: number;
+    readonly lower: number;
+    readonly higher: number;
+};
+declare type LogLevelName = 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal';
+declare const LogLevelNames: LogLevelName[];
+declare const LogLevelValues: number[];
+interface LogLevelsScaleEntry {
+    range: {
+        from: number;
+        next: number;
+    };
+    name: string;
+    test(level: number): boolean;
+}
+declare const LogLevelsScale: ReadonlyArray<LogLevelsScaleEntry>;
+declare const logLevelNameFor: (level?: number | undefined) => string;
+declare const parseLogLevel: (level: string | number) => number | undefined;
+export { logLevelNameFor, LogLevels, LogLevelNames, LogLevelValues, LogLevelsScale, parseLogLevel, LogLevelName };

frontend/node_modules/bs-logger/dist/logger/level.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var cache_getters_1 = require("../utils/cache-getters");
+var LogLevels = cache_getters_1.cacheGetters({
+    trace: 10,
+    debug: 20,
+    info: 30,
+    warn: 40,
+    error: 50,
+    fatal: 60,
+    get lower() {
+        return LogLevels.trace;
+    },
+    get higher() {
+        return LogLevels.fatal;
+    },
+}, 'lower', 'higher');
+exports.LogLevels = LogLevels;
+var LogLevelNames = ['trace', 'debug', 'info', 'warn', 'error', 'fatal'];
+exports.LogLevelNames = LogLevelNames;
+var LogLevelValues = LogLevelNames.map(function (name) { return LogLevels[name]; });
+exports.LogLevelValues = LogLevelValues;
+var LogLevelsScale = LogLevelNames.map(function (name, index, _a) {
+    var length = _a.length;
+    var first = index === 0;
+    var last = index === length - 1;
+    var from = first ? -Infinity : LogLevelValues[index];
+    var next = last ? +Infinity : LogLevelValues[index + 1];
+    var test;
+    if (first) {
+        test = function (level) { return level < next; };
+    }
+    else if (last) {
+        test = function (level) { return level >= from; };
+    }
+    else {
+        test = function (level) { return level < next && level >= from; };
+    }
+    return { range: { from: from, next: next }, name: name, test: test };
+});
+exports.LogLevelsScale = LogLevelsScale;
+var logLevelNameFor = function (level) {
+    if (level == null || isNaN(level)) {
+        return LogLevelNames[0];
+    }
+    return LogLevelsScale.find(function (_a) {
+        var test = _a.test;
+        return test(level);
+    }).name;
+};
+exports.logLevelNameFor = logLevelNameFor;
+var parseLogLevel = function (level) {
+    if (typeof level === 'string') {
+        level = level.toLowerCase();
+        if (level in LogLevels) {
+            return LogLevels[level];
+        }
+        return /^\s*[0-9]+\s*$/.test(level) ? parseInt(level.trim(), 10) : undefined;
+    }
+    return typeof level === 'number' && !isNaN(level) ? +level : undefined;
+};
+exports.parseLogLevel = parseLogLevel;

frontend/node_modules/bs-logger/dist/logger/message.d.ts

@@ -0,0 +1,18 @@
+import { LogContext } from './context';
+interface LogMessage {
+    context: LogContext;
+    message: string;
+    sequence: number;
+    time: number;
+}
+declare type LogMessageFormatter = (msg: LogMessage) => string;
+declare type LogMessageTranslator = (msg: LogMessage) => LogMessage;
+interface LogFormattersMap {
+    json: LogMessageFormatter;
+    simple: LogMessageFormatter;
+    [key: string]: LogMessageFormatter;
+}
+declare let LogFormatters: LogFormattersMap;
+declare const resetLogFormatters: () => void;
+declare const registerLogFormatter: (name: string, format: LogMessageFormatter) => void;
+export { LogMessage, LogMessageTranslator, LogMessageFormatter, LogFormatters, resetLogFormatters, registerLogFormatter, };

frontend/node_modules/bs-logger/dist/logger/message.js

@@ -0,0 +1,37 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var fast_json_stable_stringify_1 = __importDefault(require("fast-json-stable-stringify"));
+var context_1 = require("./context");
+var level_1 = require("./level");
+var LogFormatters = defaultLogFormatters();
+exports.LogFormatters = LogFormatters;
+var resetLogFormatters = function () {
+    exports.LogFormatters = LogFormatters = defaultLogFormatters();
+};
+exports.resetLogFormatters = resetLogFormatters;
+var registerLogFormatter = function (name, format) {
+    LogFormatters[name] = format;
+};
+exports.registerLogFormatter = registerLogFormatter;
+function defaultLogFormatters() {
+    return {
+        json: function (msg) { return fast_json_stable_stringify_1.default(__assign({}, msg, { time: new Date(msg.time) }), { cycles: true }); },
+        simple: function (msg) {
+            return (msg.context[context_1.LogContexts.package] || msg.context[context_1.LogContexts.application] || 'main') + "[" + (msg.context[context_1.LogContexts.namespace] || 'root') + "] (" + level_1.logLevelNameFor(msg.context[context_1.LogContexts.logLevel]).toUpperCase() + ") " + msg.message;
+        },
+    };
+}

frontend/node_modules/bs-logger/dist/logger/root.d.ts

@@ -0,0 +1,4 @@
+import { Logger } from '.';
+declare const setup: (factory?: () => Logger) => void;
+declare const rootLogger: Logger;
+export { rootLogger, setup };

frontend/node_modules/bs-logger/dist/logger/root.js

@@ -0,0 +1,79 @@
+"use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spread = (this && this.__spread) || function () {
+    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
+    return ar;
+};
+var __values = (this && this.__values) || function (o) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
+    if (m) return m.call(o);
+    return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var e_1, _a;
+var cache_getters_1 = require("../utils/cache-getters");
+var _1 = require(".");
+var level_1 = require("./level");
+var cache;
+var setup = function (factory) {
+    if (factory === void 0) { factory = function () { return _1.createLogger({ targets: process.env.LOG_TARGETS || process.env.LOG_TARGET }); }; }
+    cache = cache_getters_1.cacheGetters({
+        get root() {
+            return factory();
+        },
+    }, 'root');
+};
+exports.setup = setup;
+var rootLogger = (function () {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    return cache.root.apply(cache, __spread(args));
+});
+exports.rootLogger = rootLogger;
+var props = __spread(level_1.LogLevelNames, ['child', 'wrap']);
+var _loop_1 = function (prop) {
+    Object.defineProperty(rootLogger, prop, {
+        enumerable: true,
+        configurable: true,
+        get: function () {
+            return cache.root[prop];
+        },
+    });
+};
+try {
+    for (var props_1 = __values(props), props_1_1 = props_1.next(); !props_1_1.done; props_1_1 = props_1.next()) {
+        var prop = props_1_1.value;
+        _loop_1(prop);
+    }
+}
+catch (e_1_1) { e_1 = { error: e_1_1 }; }
+finally {
+    try {
+        if (props_1_1 && !props_1_1.done && (_a = props_1.return)) _a.call(props_1);
+    }
+    finally { if (e_1) throw e_1.error; }
+}
+cache_getters_1.cacheGetters.apply(void 0, __spread([rootLogger], props));
+setup();

frontend/node_modules/bs-logger/dist/logger/target.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import { Writable } from 'stream';
+import { LogMessageFormatter } from './message';
+interface LogTarget {
+    stream: Writable;
+    minLevel: number;
+    format: LogMessageFormatter;
+}
+declare const parseLogTargets: (targetString?: string | undefined) => LogTarget[];
+declare const DEFAULT_LOG_TARGET: string;
+export { LogTarget, DEFAULT_LOG_TARGET, parseLogTargets };

frontend/node_modules/bs-logger/dist/logger/target.js

@@ -0,0 +1,90 @@
+"use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spread = (this && this.__spread) || function () {
+    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
+    return ar;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var fs_1 = require("fs");
+var path_1 = require("path");
+var cache_getters_1 = require("../utils/cache-getters");
+var level_1 = require("./level");
+var message_1 = require("./message");
+var logTargetWithLevelRegex = new RegExp("^\\s*(.+):([0-9]+|" + level_1.LogLevelNames.join('|') + ")\\s*$", 'i');
+var parseLogTargets = function (targetString) {
+    var items = (targetString || '').split(/([^\\]),/g).reduce(function (list, item, index) {
+        if (index % 2 === 1) {
+            list[list.length - 1] += item;
+        }
+        else {
+            list.push(item);
+        }
+        return list;
+    }, []);
+    return items.reduce(function (targets, str) {
+        var format;
+        str = str.replace(/^(.+)%([a-z_][a-z0-9_]*)$/, function (_, before, key) {
+            format = message_1.LogFormatters[key];
+            return before;
+        });
+        var pieces = str.match(logTargetWithLevelRegex);
+        var file;
+        var level;
+        if (pieces) {
+            file = pieces[1].trim();
+            level = pieces[2].trim();
+        }
+        else {
+            file = str.trim();
+        }
+        var append = file.endsWith('+');
+        if (append) {
+            file = file.slice(0, -1).trim();
+        }
+        file = file.replace(/\\,/g, ',');
+        if (!file) {
+            return targets;
+        }
+        var isStandardFd = /^(stdout|stderr)$/i.test(file);
+        if (format == null) {
+            format = isStandardFd ? message_1.LogFormatters.simple : message_1.LogFormatters.json;
+        }
+        var target = cache_getters_1.cacheGetters({
+            format: format,
+            get minLevel() {
+                return level_1.parseLogLevel(level) || -Infinity;
+            },
+            get stream() {
+                if (isStandardFd) {
+                    return process[file.toLowerCase()];
+                }
+                else {
+                    return fs_1.createWriteStream(path_1.resolve(process.cwd(), file), {
+                        flags: append ? 'a' : 'w',
+                        autoClose: true,
+                        encoding: 'utf8',
+                    });
+                }
+            },
+        }, 'minLevel', 'stream');
+        return __spread(targets, [target]);
+    }, []);
+};
+exports.parseLogTargets = parseLogTargets;
+var DEFAULT_LOG_TARGET = "stderr:" + level_1.LogLevels.warn;
+exports.DEFAULT_LOG_TARGET = DEFAULT_LOG_TARGET;