Programmatic API

/**
 * Karma server class for managing test environment
 * @extends EventEmitter
 */
class Server extends EventEmitter {
  /**
   * Create new Karma server instance. Constructor automatically starts the server.
   * @param cliOptionsOrConfig - Configuration object or CLI options
   * @param done - Optional callback function (defaults to process.exit)
   */
  constructor(cliOptionsOrConfig: Config | Object, done?: Function);
  
  /**
   * Stop the Karma server gracefully
   * @returns Promise that resolves when server is stopped
   */
  stop(): Promise<void>;
  
  /**
   * Refresh all watched files
   * @returns Promise<void>
   */
  refreshFiles(): Promise<void>;
  
  /**
   * Refresh specific file by path
   * @param path - File path to refresh
   * @returns Promise<void>
   */
  refreshFile(path: string): Promise<void>;
  
  /**
   * Get dependency injection token value
   * @param token - Token name to retrieve
   * @returns Any value associated with the token
   */
  get(token: string): any;
  
  /**
   * Emit exit event asynchronously
   * @param code - Exit code
   * @returns Promise that resolves when all exit listeners complete
   */
  emitExitAsync(code: number): Promise<void>;
}

const karma = require('karma');

// Create server with configuration (automatically starts)
const server = new karma.Server({
  configFile: './karma.conf.js',
  singleRun: true,
  browsers: ['Chrome']
}, (exitCode) => {
  console.log('Tests completed with exit code:', exitCode);
});

// Listen to server events
server.on('listening', () => {
  console.log('Karma server started');
});

server.on('browser_register', (browser) => {
  console.log('Browser connected:', browser.name);
});

server.on('run_complete', (browsers, results) => {
  console.log('Test run complete:', results);
});

// Server starts automatically from constructor
// Use server.stop() to stop gracefully

/**
 * Execute tests on running Karma server
 * @param cliOptionsOrConfig - Configuration object or CLI options
 * @param done - Callback function with exit code
 * @returns EventEmitter for progress events
 */
function run(cliOptionsOrConfig: Config | Object, done?: Function): EventEmitter;

const karma = require('karma');

// Run tests and get progress updates
const runner = karma.runner.run({
  port: 9876,
  hostname: 'localhost'
}, (exitCode) => {
  console.log('Test run finished with code:', exitCode);
});

// Listen to progress events
runner.on('progress', (data) => {
  console.log('Test progress:', data);
});

// Alternative with async/await
const config = karma.config.parseConfig('./karma.conf.js', {});
const runResult = karma.runner.run(config);

/**
 * Stop running Karma server
 * @param cliOptionsOrConfig - Configuration object or CLI options
 * @param done - Callback function with exit code
 */
function stop(cliOptionsOrConfig: Config | Object, done?: Function): void;

const karma = require('karma');

// Stop server with callback
karma.stopper.stop({
  port: 9876,
  hostname: 'localhost'
}, (exitCode) => {
  if (exitCode === 0) {
    console.log('Server stopped successfully');
  } else {
    console.error('Failed to stop server');
  }
});

// Stop with configuration
const config = karma.config.parseConfig('./karma.conf.js');
karma.stopper.stop(config);

/**
 * Browser launcher class for managing browser instances
 */
class Launcher {
  /**
   * Create launcher instance
   * @param server - Karma server instance
   * @param emitter - Event emitter
   * @param injector - Dependency injector
   */
  constructor(server: Server, emitter: EventEmitter, injector: any);
  
  /**
   * Launch browsers by name
   * @param names - Array of browser names to launch
   * @param concurrency - Maximum concurrent browsers
   * @returns Promise that resolves when browsers are launched
   */
  launch(names: string[], concurrency: number): Promise<void>;
  
  /**
   * Create single browser launcher function
   * @param protocol - Server protocol
   * @param hostname - Server hostname
   * @param port - Server port
   * @param urlRoot - URL root path
   * @param upstreamProxy - Upstream proxy config
   * @param processKillTimeout - Process kill timeout
   * @returns Browser instance
   */
  launchSingle(
    protocol: string,
    hostname: string,
    port: number,
    urlRoot: string,
    upstreamProxy: any,
    processKillTimeout: number
  ): Browser;
  
  /**
   * Kill specific browser by ID
   * @param id - Browser ID
   * @returns True if browser was found and killed
   */
  kill(id: string): boolean;
  
  /**
   * Restart browser by ID
   * @param id - Browser ID
   * @returns True if browser was found and restarted
   */
  restart(id: string): boolean;
  
  /**
   * Kill all launched browsers
   * @returns Promise that resolves when all browsers are killed
   */
  killAll(): Promise<void>;
  
  /**
   * Check if all browsers are captured
   * @returns True if all browsers captured
   */
  areAllCaptured(): boolean;
  
  /**
   * Mark browser as captured
   * @param id - Browser ID
   */
  markCaptured(id: string): void;
  
  /**
   * Get all browser instances
   * @returns Array of browser instances
   */
  getBrowsers(): Browser[];
  
  /**
   * Get number of captured browsers
   * @returns Number of captured browsers
   */
  getCapturedBrowsers(): number;
}

interface Constants {
  VERSION: string;                    // Karma version
  DEFAULT_PORT: number;               // Default port (9876)
  DEFAULT_HOSTNAME: string;           // Default hostname ('localhost')
  DEFAULT_LISTEN_ADDR: string;        // Default listen address ('0.0.0.0')
  
  // Log levels
  LOG_DISABLE: string;                // 'OFF'
  LOG_ERROR: string;                  // 'ERROR'
  LOG_WARN: string;                   // 'WARN'
  LOG_INFO: string;                   // 'INFO'
  LOG_DEBUG: string;                  // 'DEBUG'
  LOG_LOG: string;                    // 'LOG'
  LOG_PRIORITIES: string[];           // Log levels in priority order
  
  // Patterns
  COLOR_PATTERN: string;              // Default color pattern
  NO_COLOR_PATTERN: string;           // Default no-color pattern
  CONSOLE_APPENDER: Object;           // Default console appender
  EXIT_CODE: string;                  // Internal exit code marker
}

const karma = require('karma');

console.log('Karma version:', karma.constants.VERSION);
console.log('Default port:', karma.constants.DEFAULT_PORT);

// Use log levels
const config = {
  logLevel: karma.constants.LOG_DEBUG,
  port: karma.constants.DEFAULT_PORT
};

// Server lifecycle events
'listening'              // Server started listening
'browser_register'       // Browser connected (browser)
'browser_start'         // Browser started (browser)  
'browser_complete'      // Browser finished (browser, result)
'browser_error'         // Browser error (browser, error)
'run_start'            // Test run started (browsers)
'run_complete'         // Test run finished (browsers, results)
'file_list_modified'   // File list changed

// Progress events  
'spec_complete'        // Individual test completed (browser, result)
'coverage_complete'    // Coverage data available (browser, coverage)

// Runner progress events
'progress'             // Test execution progress (data)

const server = new karma.Server(config);

server.on('listening', () => {
  console.log('Karma server listening on port', server.get('config.port'));
});

server.on('run_complete', (browsers, results) => {
  console.log('Tests completed:');
  console.log('  Success:', results.success);
  console.log('  Failed:', results.failed);
  console.log('  Total time:', results.totalTime + 'ms');
});

server.on('browser_error', (browser, error) => {
  console.error('Browser error in', browser.name, ':', error);
});