chore: import upstream snapshot with attribution

test/commands/redteam/init.test.ts

@@ -0,0 +1,123 @@
+import { AbortPromptError, ExitPromptError } from '@inquirer/core';
+import { Command } from 'commander';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { initCommand } from '../../../src/commands/redteam/init';
+import { getDefaultPort } from '../../../src/constants';
+import logger from '../../../src/logger';
+import { redteamInit } from '../../../src/redteam/commands/init';
+import { startServer } from '../../../src/server/server';
+import telemetry from '../../../src/telemetry';
+import { setupEnv } from '../../../src/util/index';
+import { BrowserBehavior, checkServerRunning, openBrowser } from '../../../src/util/server';
+import { mockProcessEnv } from '../../util/utils';
+
+vi.mock('../../../src/logger');
+vi.mock('../../../src/redteam/commands/init');
+vi.mock('../../../src/server/server');
+vi.mock('../../../src/telemetry');
+vi.mock('../../../src/util/index', async (importOriginal) => ({
+  ...(await importOriginal<typeof import('../../../src/util/index')>()),
+  setupEnv: vi.fn(),
+}));
+vi.mock('../../../src/util/server');
+
+describe('redteam init command', () => {
+  let originalExitCode: number | string | null | undefined;
+  let program: Command;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.mocked(redteamInit).mockReset();
+    vi.mocked(startServer).mockReset();
+    vi.mocked(telemetry.record).mockReset();
+    vi.mocked(setupEnv).mockReset();
+    vi.mocked(checkServerRunning).mockReset();
+    vi.mocked(openBrowser).mockReset();
+
+    originalExitCode = process.exitCode;
+    process.exitCode = 0;
+    program = new Command();
+    initCommand(program);
+  });
+
+  afterEach(() => {
+    process.exitCode = originalExitCode;
+    vi.restoreAllMocks();
+  });
+
+  it('runs the reusable flow in non-GUI mode', async () => {
+    await program.parseAsync([
+      'node',
+      'test',
+      'init',
+      'project-dir',
+      '--no-gui',
+      '--env-file',
+      '.env.test',
+    ]);
+
+    expect(setupEnv).toHaveBeenCalledWith('.env.test');
+    expect(redteamInit).toHaveBeenCalledWith('project-dir');
+    expect(checkServerRunning).not.toHaveBeenCalled();
+  });
+
+  it('opens the redteam create UI when a server is already running', async () => {
+    const restoreEnv = mockProcessEnv({ DISPLAY: ':99' });
+    vi.mocked(checkServerRunning).mockResolvedValue(true);
+
+    try {
+      await program.parseAsync(['node', 'test', 'init']);
+    } finally {
+      restoreEnv();
+    }
+
+    expect(openBrowser).toHaveBeenCalledWith(BrowserBehavior.OPEN_TO_REDTEAM_CREATE);
+    expect(startServer).not.toHaveBeenCalled();
+    expect(redteamInit).not.toHaveBeenCalled();
+  });
+
+  it('starts the redteam create UI when no server is running', async () => {
+    const restoreEnv = mockProcessEnv({ DISPLAY: ':99' });
+    vi.mocked(checkServerRunning).mockResolvedValue(false);
+
+    try {
+      await program.parseAsync(['node', 'test', 'init']);
+    } finally {
+      restoreEnv();
+    }
+
+    expect(startServer).toHaveBeenCalledWith(
+      getDefaultPort(),
+      BrowserBehavior.OPEN_TO_REDTEAM_CREATE,
+    );
+    expect(openBrowser).not.toHaveBeenCalled();
+    expect(redteamInit).not.toHaveBeenCalled();
+  });
+
+  it.each([
+    new ExitPromptError(),
+    new AbortPromptError(),
+  ])('marks %s cancellation without hard-exiting', async (error) => {
+    process.exitCode = undefined;
+    vi.mocked(redteamInit).mockRejectedValueOnce(error);
+    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => undefined) as never);
+
+    await expect(program.parseAsync(['node', 'test', 'init', '--no-gui'])).resolves.toBe(program);
+
+    expect(telemetry.record).toHaveBeenCalledWith('funnel', {
+      type: 'redteam onboarding',
+      step: 'early exit',
+    });
+    expect(logger.info).toHaveBeenCalled();
+    expect(process.exitCode).toBe(130);
+    expect(exitSpy).not.toHaveBeenCalled();
+  });
+
+  it('rethrows unexpected errors', async () => {
+    vi.mocked(redteamInit).mockRejectedValueOnce(new Error('unexpected failure'));
+
+    await expect(program.parseAsync(['node', 'test', 'init', '--no-gui'])).rejects.toThrow(
+      'unexpected failure',
+    );
+  });
+});

test/commands/redteam/report.test.ts

@@ -0,0 +1,84 @@
+import { Command } from 'commander';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { redteamReportCommand } from '../../../src/commands/redteam/report';
+import { startServer } from '../../../src/server/server';
+import { setConfigDirectoryPath } from '../../../src/util/config/manage';
+import { setupEnv } from '../../../src/util/index';
+import { BrowserBehavior, checkServerRunning, openBrowser } from '../../../src/util/server';
+
+vi.mock('../../../src/server/server');
+vi.mock('../../../src/util');
+vi.mock('../../../src/util/config/manage', () => ({
+  getConfigDirectoryPath: vi.fn().mockReturnValue('/tmp/test-config'),
+  setConfigDirectoryPath: vi.fn(),
+  maybeReadConfig: vi.fn(),
+  readConfigs: vi.fn(),
+}));
+vi.mock('../../../src/util/server');
+
+describe('redteamReportCommand', () => {
+  let program: Command;
+
+  beforeEach(() => {
+    program = new Command();
+    vi.clearAllMocks();
+  });
+
+  it('should set up command with correct options', () => {
+    redteamReportCommand(program);
+
+    const cmd = program.commands[0];
+    expect(cmd.name()).toBe('report');
+    expect(cmd.description()).toBe('Start browser UI and open to report');
+    expect(cmd.opts()).toEqual({
+      port: expect.any(String),
+      filterDescription: undefined,
+      envPath: undefined,
+    });
+  });
+
+  it('should handle report command with directory', async () => {
+    redteamReportCommand(program);
+    const cmd = program.commands[0];
+
+    vi.mocked(checkServerRunning).mockResolvedValue(false);
+
+    await cmd.parseAsync(['node', 'test', 'testdir', '--port', '3000']);
+
+    expect(setupEnv).toHaveBeenCalledWith(undefined);
+    expect(setConfigDirectoryPath).toHaveBeenCalledWith('testdir');
+    expect(startServer).toHaveBeenCalledWith('3000', BrowserBehavior.OPEN_TO_REPORT);
+  });
+
+  it('should open browser if server is already running', async () => {
+    redteamReportCommand(program);
+    const cmd = program.commands[0];
+
+    vi.mocked(checkServerRunning).mockResolvedValue(true);
+
+    await cmd.parseAsync(['node', 'test', '--port', '3000']);
+
+    expect(openBrowser).toHaveBeenCalledWith(BrowserBehavior.OPEN_TO_REPORT);
+    expect(startServer).not.toHaveBeenCalled();
+  });
+
+  it('should ignore filter description option', async () => {
+    redteamReportCommand(program);
+    const cmd = program.commands[0];
+
+    vi.mocked(checkServerRunning).mockResolvedValue(false);
+
+    await cmd.parseAsync(['node', 'test', '--filter-description', 'test.*']);
+
+    expect(startServer).toHaveBeenCalledWith(expect.any(String), BrowserBehavior.OPEN_TO_REPORT);
+  });
+
+  it('should handle report command with env file path', async () => {
+    redteamReportCommand(program);
+    const cmd = program.commands[0];
+
+    await cmd.parseAsync(['node', 'test', '--env-file', '.env.test']);
+
+    expect(setupEnv).toHaveBeenCalledWith('.env.test');
+  });
+});

test/commands/redteam/setup.test.ts

@@ -0,0 +1,92 @@
+import { Command } from 'commander';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { redteamSetupCommand } from '../../../src/commands/redteam/setup';
+import { getDefaultPort } from '../../../src/constants';
+import { startServer } from '../../../src/server/server';
+import { setConfigDirectoryPath } from '../../../src/util/config/manage';
+import { setupEnv } from '../../../src/util/index';
+import { BrowserBehavior, checkServerRunning, openBrowser } from '../../../src/util/server';
+
+vi.mock('../../../src/server/server');
+vi.mock('../../../src/util/server');
+vi.mock('../../../src/util', async (importOriginal) => {
+  return {
+    ...(await importOriginal()),
+    setupEnv: vi.fn(),
+  };
+});
+vi.mock('../../../src/util/config/manage', async (importOriginal) => {
+  return {
+    ...(await importOriginal()),
+    setConfigDirectoryPath: vi.fn(),
+  };
+});
+
+describe('redteamSetupCommand', () => {
+  let program: Command;
+
+  beforeEach(() => {
+    program = new Command();
+    vi.clearAllMocks();
+  });
+
+  it('should register the setup command with correct options', () => {
+    redteamSetupCommand(program);
+    const setupCmd = program.commands.find((cmd) => cmd.name() === 'setup');
+
+    expect(setupCmd).toBeDefined();
+    expect(setupCmd?.description()).toBe('Start browser UI and open to redteam setup');
+    expect(setupCmd?.opts().port).toBe(getDefaultPort().toString());
+  });
+
+  it('should handle setup command without directory', async () => {
+    vi.mocked(checkServerRunning).mockResolvedValue(false);
+    redteamSetupCommand(program);
+
+    await program.parseAsync(['node', 'test', 'setup', '--port', '3000']);
+
+    expect(setupEnv).toHaveBeenCalledWith(undefined);
+    expect(startServer).toHaveBeenCalledWith('3000', BrowserBehavior.OPEN_TO_REDTEAM_CREATE);
+  });
+
+  it('should handle setup command with directory', async () => {
+    vi.mocked(checkServerRunning).mockResolvedValue(false);
+    redteamSetupCommand(program);
+
+    await program.parseAsync(['node', 'test', 'setup', 'test-dir', '--port', '3000']);
+
+    expect(setConfigDirectoryPath).toHaveBeenCalledWith('test-dir');
+    expect(startServer).toHaveBeenCalledWith('3000', BrowserBehavior.OPEN_TO_REDTEAM_CREATE);
+  });
+
+  it('should open browser if server is already running', async () => {
+    vi.mocked(checkServerRunning).mockResolvedValue(true);
+    redteamSetupCommand(program);
+
+    await program.parseAsync(['node', 'test', 'setup']);
+
+    expect(openBrowser).toHaveBeenCalledWith(BrowserBehavior.OPEN_TO_REDTEAM_CREATE);
+    expect(startServer).not.toHaveBeenCalled();
+  });
+
+  it('should ignore filter description option', async () => {
+    vi.mocked(checkServerRunning).mockResolvedValue(false);
+    redteamSetupCommand(program);
+
+    await program.parseAsync(['node', 'test', 'setup', '--filter-description', 'test.*']);
+
+    expect(startServer).toHaveBeenCalledWith(
+      getDefaultPort().toString(),
+      BrowserBehavior.OPEN_TO_REDTEAM_CREATE,
+    );
+  });
+
+  it('should handle setup command with env file path', async () => {
+    vi.mocked(checkServerRunning).mockResolvedValue(false);
+    redteamSetupCommand(program);
+
+    await program.parseAsync(['node', 'test', 'setup', '--env-file', '.env.test']);
+
+    expect(setupEnv).toHaveBeenCalledWith('.env.test');
+  });
+});