@cdot65/prisma-airs-cli 2.11.0 → 3.0.0

package/dist/cli/commands/redteam.js

@@ -1,1071 +0,0 @@
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import chalk from 'chalk';
-import { SdkPromptSetService } from '../../airs/promptsets.js';
-import { SdkRedTeamService } from '../../airs/redteam.js';
-import { resolveOutputDir } from '../../backup/io.js';
-import { loadConfig } from '../../config/loader.js';
-import { buildAttackListFootnote, renderAttackList, renderAuthValidation, renderBackupHeader, renderBackupSummary, renderCategories, renderCustomAttackList, renderCustomReport, renderError, renderEulaContent, renderEulaStatus, renderInstanceDetail, renderInstanceResponse, renderPromptDetail, renderPromptList, renderPromptSetDetail, renderPromptSetList, renderPropertyNames, renderPropertyValues, renderRedteamHeader, renderRegistryCredentials, renderRestoreSummary, renderScanList, renderScanProgress, renderScanStatus, renderStaticReport, renderTargetDetail, renderTargetList, renderTargetTemplates, renderVersionInfo, } from '../renderer/index.js';
-import { backupTargets } from './backup.js';
-import { restoreTargets } from './restore.js';
-/** Create an SdkRedTeamService from config. */
-async function createService() {
-    const config = await loadConfig();
-    return new SdkRedTeamService({
-        clientId: config.mgmtClientId,
-        clientSecret: config.mgmtClientSecret,
-        tsgId: config.mgmtTsgId,
-        tokenEndpoint: config.mgmtTokenEndpoint,
-    });
-}
-/** Create an SdkPromptSetService from config. */
-async function createPromptSetService() {
-    const config = await loadConfig();
-    return new SdkPromptSetService({
-        clientId: config.mgmtClientId,
-        clientSecret: config.mgmtClientSecret,
-        tsgId: config.mgmtTsgId,
-        tokenEndpoint: config.mgmtTokenEndpoint,
-    });
-}
-/** Parse `--goals` arg as inline JSON array (starts with `[`) or path to a JSON file. */
-export function parseAttackGoals(input) {
-    const trimmed = input.trim();
-    const raw = trimmed.startsWith('[') ? trimmed : fs.readFileSync(trimmed, 'utf-8');
-    let parsed;
-    try {
-        parsed = JSON.parse(raw);
-    }
-    catch (err) {
-        throw new Error(`--goals: invalid JSON (${err instanceof Error ? err.message : err})`);
-    }
-    if (!Array.isArray(parsed) || !parsed.every((g) => typeof g === 'string' && g.length > 0)) {
-        throw new Error('--goals: expected a JSON array of non-empty strings');
-    }
-    return parsed;
-}
-/** Parse a string flag as a positive integer. */
-export function parsePositiveInt(input, flag) {
-    const n = Number.parseInt(input, 10);
-    if (!Number.isFinite(n) || n <= 0) {
-        throw new Error(`${flag}: expected a positive integer, got "${input}"`);
-    }
-    return n;
-}
-/** Valid provider names for target init templates. */
-export const VALID_TARGET_PROVIDERS = [
-    'OPENAI',
-    'HUGGING_FACE',
-    'DATABRICKS',
-    'BEDROCK',
-    'REST',
-    'STREAMING',
-];
-/** Build a target config scaffold from a provider template. */
-export function buildTargetScaffold(provider, templates) {
-    const key = provider.toUpperCase();
-    if (!VALID_TARGET_PROVIDERS.includes(key)) {
-        throw new Error(`Unknown provider "${provider}". Valid providers: ${VALID_TARGET_PROVIDERS.join(', ')}`);
-    }
-    return {
-        name: '',
-        target_type: 'APPLICATION',
-        connection_params: templates[key] ?? {},
-        target_background: {},
-        additional_context: {},
-        target_metadata: {},
-    };
-}
-/** Register the `redteam` command group. */
-export function registerRedteamCommand(program) {
-    const redteam = program.command('redteam').description('AI Red Team scan operations');
-    // -----------------------------------------------------------------------
-    // redteam abort — abort a running scan
-    // -----------------------------------------------------------------------
-    redteam
-        .command('abort <jobId>')
-        .description('Abort a running scan')
-        .action(async (jobId) => {
-        try {
-            renderRedteamHeader();
-            const service = await createService();
-            await service.abortScan(jobId);
-            console.log(`  Scan ${jobId} aborted.\n`);
-        }
-        catch (err) {
-            renderError(err instanceof Error ? err.message : String(err));
-            process.exit(1);
-        }
-    });
-    // -----------------------------------------------------------------------
-    // redteam categories — list attack categories
-    // -----------------------------------------------------------------------
-    redteam
-        .command('categories')
-        .description('List available attack categories')
-        .action(async () => {
-        try {
-            renderRedteamHeader();
-            const service = await createService();
-            const categories = await service.getCategories();
-            renderCategories(categories);
-        }
-        catch (err) {
-            renderError(err instanceof Error ? err.message : String(err));
-            process.exit(1);
-        }
-    });
-    // -----------------------------------------------------------------------
-    // redteam eula — EULA management subcommands
-    // -----------------------------------------------------------------------
-    const eula = redteam.command('eula').description('Manage Red Team EULA');
-    eula
-        .command('status')
-        .description('Check EULA acceptance status')
-        .action(async () => {
-        try {
-            renderRedteamHeader();
-            const service = await createService();
-            const status = await service.getEulaStatus();
-            renderEulaStatus(status);
-        }
-        catch (err) {
-            renderError(err instanceof Error ? err.message : String(err));
-            process.exit(1);
-        }
-    });
-    eula
-        .command('content')
-        .description('Display EULA content')
-        .action(async () => {
-        try {
-            renderRedteamHeader();
-            const service = await createService();
-            const content = await service.getEulaContent();
-            renderEulaContent(content);
-        }
-        catch (err) {
-            renderError(err instanceof Error ? err.message : String(err));
-            process.exit(1);
-        }
-    });
-    eula
-        .command('accept')
-        .description('Accept the EULA')
-        .option('--confirm', 'Skip confirmation prompt')
-        .action(async (opts) => {
-        try {
-            renderRedteamHeader();
-            const service = await createService();
-            const content = await service.getEulaContent();
-            if (!opts.confirm) {
-                renderEulaContent(content);
-                console.log('  Pass --confirm to accept.\n');
-                return;
-            }
-            const result = await service.acceptEula(content.content);
-            renderEulaStatus(result);
-            console.log('  EULA accepted.\n');
-        }
-        catch (err) {
-            renderError(err instanceof Error ? err.message : String(err));
-            process.exit(1);
-        }
-    });
-    // -----------------------------------------------------------------------
-    // redteam instances — instance CRUD subcommands
-    // -----------------------------------------------------------------------
-    const instances = redteam.command('instances').description('Manage Red Team instances');
-    instances
-        .command('create')
-        .description('Create an instance')
-        .requiredOption('--tsg-id <id>', 'TSG ID')
-        .requiredOption('--tenant-id <id>', 'Tenant ID')
-        .requiredOption('--app-id <id>', 'App ID')
-        .requiredOption('--region <region>', 'Region')
-        .action(async (opts) => {
-        try {
-            renderRedteamHeader();
-            const service = await createService();
-            const result = await service.createInstance({
-                tsgId: opts.tsgId,
-                tenantId: opts.tenantId,
-                appId: opts.appId,
-                region: opts.region,
-            });
-            renderInstanceResponse(result);
-        }
-        catch (err) {
-            renderError(err instanceof Error ? err.message : String(err));
-            process.exit(1);
-        }
-    });
-    instances
-        .command('get <tenantId>')
-        .description('Get instance details')
-        .action(async (tenantId) => {
-        try {
-            renderRedteamHeader();
-            const service = await createService();
-            const result = await service.getInstance(tenantId);
-            renderInstanceDetail(result);
-        }
-        catch (err) {
-            renderError(err instanceof Error ? err.message : String(err));
-            process.exit(1);
-        }
-    });
-    instances
-        .command('update <tenantId>')
-        .description('Update an instance')
-        .requiredOption('--tsg-id <id>', 'TSG ID')
-        .requiredOption('--app-id <id>', 'App ID')
-        .requiredOption('--region <region>', 'Region')
-        .action(async (tenantId, opts) => {
-        try {
-            renderRedteamHeader();
-            const service = await createService();
-            const result = await service.updateInstance(tenantId, {
-                tsgId: opts.tsgId,
-                tenantId,
-                appId: opts.appId,
-                region: opts.region,
-            });
-            renderInstanceResponse(result);
-        }
-        catch (err) {
-            renderError(err instanceof Error ? err.message : String(err));
-            process.exit(1);
-        }
-    });
-    instances
-        .command('delete <tenantId>')
-        .description('Delete an instance')
-        .action(async (tenantId) => {
-        try {
-            renderRedteamHeader();
-            const service = await createService();
-            const result = await service.deleteInstance(tenantId);
-            renderInstanceResponse(result);
-            console.log(`  Instance ${tenantId} deleted.\n`);
-        }
-        catch (err) {
-            renderError(err instanceof Error ? err.message : String(err));
-            process.exit(1);
-        }
-    });
-    // -----------------------------------------------------------------------
-    // redteam devices — device management subcommands
-    // -----------------------------------------------------------------------
-    const devices = redteam.command('devices').description('Manage Red Team devices');
-    devices
-        .command('create <tenantId>')
-        .description('Create devices for an instance')
-        .requiredOption('--config <path>', 'JSON file with device request')
-        .action(async (tenantId, opts) => {
-        try {
-            renderRedteamHeader();
-            const service = await createService();
-            const config = JSON.parse(fs.readFileSync(opts.config, 'utf-8'));
-            const result = await service.createDevices(tenantId, config);
-            console.log('  Devices created:');
-            console.log(`    ${JSON.stringify(result, null, 2)}\n`);
-        }
-        catch (err) {
-            renderError(err instanceof Error ? err.message : String(err));
-            process.exit(1);
-        }
-    });
-    devices
-        .command('update <tenantId>')
-        .description('Update devices for an instance (PATCH)')
-        .requiredOption('--config <path>', 'JSON file with device request')
-        .action(async (tenantId, opts) => {
-        try {
-            renderRedteamHeader();
-            const service = await createService();
-            const config = JSON.parse(fs.readFileSync(opts.config, 'utf-8'));
-            const result = await service.updateDevices(tenantId, config);
-            console.log('  Devices updated:');
-            console.log(`    ${JSON.stringify(result, null, 2)}\n`);
-        }
-        catch (err) {
-            renderError(err instanceof Error ? err.message : String(err));
-            process.exit(1);
-        }
-    });
-    devices
-        .command('delete <tenantId>')
-        .description('Delete devices by serial numbers')
-        .requiredOption('--serial-numbers <list>', 'Comma-separated serial numbers')
-        .action(async (tenantId, opts) => {
-        try {
-            renderRedteamHeader();
-            const service = await createService();
-            const result = await service.deleteDevices(tenantId, opts.serialNumbers);
-            console.log('  Devices deleted:');
-            console.log(`    ${JSON.stringify(result, null, 2)}\n`);
-        }
-        catch (err) {
-            renderError(err instanceof Error ? err.message : String(err));
-            process.exit(1);
-        }
-    });
-    // -----------------------------------------------------------------------
-    // redteam registry-credentials — registry credentials
-    // -----------------------------------------------------------------------
-    redteam
-        .command('registry-credentials')
-        .description('Get or create registry credentials')
-        .action(async () => {
-        try {
-            renderRedteamHeader();
-            const service = await createService();
-            const creds = await service.getRegistryCredentials();
-            renderRegistryCredentials(creds);
-        }
-        catch (err) {
-            renderError(err instanceof Error ? err.message : String(err));
-            process.exit(1);
-        }
-    });
-    // -----------------------------------------------------------------------
-    // redteam list — list recent scans
-    // -----------------------------------------------------------------------
-    redteam
-        .command('list')
-        .description('List recent scans')
-        .option('--status <status>', 'Filter by status (QUEUED, RUNNING, COMPLETED, FAILED, ABORTED)')
-        .option('--type <type>', 'Filter by job type (STATIC, DYNAMIC, CUSTOM)')
-        .option('--target <uuid>', 'Filter by target UUID')
-        .option('--limit <n>', 'Max results', '10')
-        .option('--output <format>', 'Output format: pretty, table, csv, json, yaml', 'pretty')
-        .action(async (opts) => {
-        try {
-            const fmt = opts.output;
-            if (fmt === 'pretty')
-                renderRedteamHeader();
-            const service = await createService();
-            const scans = await service.listScans({
-                status: opts.status,
-                jobType: opts.type,
-                targetId: opts.target,
-                limit: Number.parseInt(opts.limit, 10),
-            });
-            renderScanList(scans, fmt);
-        }
-        catch (err) {
-            renderError(err instanceof Error ? err.message : String(err));
-            process.exit(1);
-        }
-    });
-    // -----------------------------------------------------------------------
-    // redteam prompt-sets — prompt set CRUD subcommands
-    // -----------------------------------------------------------------------
-    const promptSets = redteam.command('prompt-sets').description('Manage custom prompt sets');
-    promptSets
-        .command('list')
-        .description('List custom prompt sets')
-        .option('--output <format>', 'Output format: pretty, table, csv, json, yaml', 'pretty')
-        .action(async (opts) => {
-        try {
-            const fmt = opts.output;
-            if (fmt === 'pretty')
-                renderRedteamHeader();
-            const service = await createPromptSetService();
-            const sets = await service.listPromptSets();
-            renderPromptSetList(sets, fmt);
-        }
-        catch (err) {
-            renderError(err instanceof Error ? err.message : String(err));
-            process.exit(1);
-        }
-    });
-    promptSets
-        .command('get <uuid>')
-        .description('Get prompt set details')
-        .option('--output <format>', 'Output format: pretty, json, yaml', 'pretty')
-        .action(async (uuid, opts) => {
-        try {
-            const fmt = opts.output;
-            if (fmt === 'pretty')
-                renderRedteamHeader();
-            const service = await createPromptSetService();
-            const ps = await service.getPromptSet(uuid);
-            const info = await service.getPromptSetVersionInfo(uuid);
-            if (fmt === 'pretty') {
-                renderPromptSetDetail(ps);
-                renderVersionInfo(info);
-            }
-            else {
-                renderPromptSetDetail(ps, fmt, info);
-            }
-        }
-        catch (err) {
-            renderError(err instanceof Error ? err.message : String(err));
-            process.exit(1);
-        }
-    });
-    promptSets
-        .command('create')
-        .description('Create a new prompt set')
-        .requiredOption('--name <name>', 'Prompt set name')
-        .option('--description <desc>', 'Prompt set description')
-        .action(async (opts) => {
-        try {
-            renderRedteamHeader();
-            const service = await createPromptSetService();
-            const result = await service.createPromptSet(opts.name, opts.description);
-            console.log(`  Prompt set created: ${result.uuid}\n`);
-            console.log(`    Name: ${result.name}\n`);
-        }
-        catch (err) {
-            renderError(err instanceof Error ? err.message : String(err));
-            process.exit(1);
-        }
-    });
-    promptSets
-        .command('update <uuid>')
-        .description('Update a prompt set')
-        .option('--name <name>', 'New name')
-        .option('--description <desc>', 'New description')
-        .action(async (uuid, opts) => {
-        try {
-            renderRedteamHeader();
-            const service = await createPromptSetService();
-            const request = {};
-            if (opts.name)
-                request.name = opts.name;
-            if (opts.description)
-                request.description = opts.description;
-            const result = await service.updatePromptSet(uuid, request);
-            renderPromptSetDetail(result);
-        }
-        catch (err) {
-            renderError(err instanceof Error ? err.message : String(err));
-            process.exit(1);
-        }
-    });
-    promptSets
-        .command('archive <uuid>')
-        .description('Archive a prompt set')
-        .option('--unarchive', 'Unarchive instead')
-        .action(async (uuid, opts) => {
-        try {
-            renderRedteamHeader();
-            const service = await createPromptSetService();
-            const archive = !opts.unarchive;
-            await service.archivePromptSet(uuid, archive);
-            console.log(`  Prompt set ${uuid} ${archive ? 'archived' : 'unarchived'}.\n`);
-        }
-        catch (err) {
-            renderError(err instanceof Error ? err.message : String(err));
-            process.exit(1);
-        }
-    });
-    promptSets
-        .command('download <uuid>')
-        .description('Download CSV template for a prompt set')
-        .option('--output <path>', 'Output file path')
-        .action(async (uuid, opts) => {
-        try {
-            renderRedteamHeader();
-            const service = await createPromptSetService();
-            const csv = await service.downloadTemplate(uuid);
-            const outPath = opts.output || `${uuid}-template.csv`;
-            fs.writeFileSync(outPath, csv, 'utf-8');
-            console.log(`  Template saved to ${outPath}\n`);
-        }
-        catch (err) {
-            renderError(err instanceof Error ? err.message : String(err));
-            process.exit(1);
-        }
-    });
-    promptSets
-        .command('upload <uuid> <file>')
-        .description('Upload CSV prompts to a prompt set')
-        .action(async (uuid, file) => {
-        try {
-            renderRedteamHeader();
-            const service = await createPromptSetService();
-            const content = fs.readFileSync(file);
-            const filename = path.basename(file);
-            const blob = new File([content], filename, { type: 'text/csv' });
-            const result = await service.uploadPromptsCsv(uuid, blob);
-            console.log(`  ${result.message}\n`);
-        }
-        catch (err) {
-            renderError(err instanceof Error ? err.message : String(err));
-            process.exit(1);
-        }
-    });
-    // -----------------------------------------------------------------------
-    // redteam prompts — individual prompt CRUD subcommands
-    // -----------------------------------------------------------------------
-    const prompts = redteam.command('prompts').description('Manage prompts within prompt sets');
-    prompts
-        .command('list <setUuid>')
-        .description('List prompts in a prompt set')
-        .option('--limit <n>', 'Max results', '50')
-        .action(async (setUuid, opts) => {
-        try {
-            renderRedteamHeader();
-            const service = await createPromptSetService();
-            const list = await service.listPrompts(setUuid, {
-                limit: Number.parseInt(opts.limit, 10),
-            });
-            renderPromptList(list);
-        }
-        catch (err) {
-            renderError(err instanceof Error ? err.message : String(err));
-            process.exit(1);
-        }
-    });
-    prompts
-        .command('get <setUuid> <promptUuid>')
-        .description('Get prompt details')
-        .action(async (setUuid, promptUuid) => {
-        try {
-            renderRedteamHeader();
-            const service = await createPromptSetService();
-            const prompt = await service.getPrompt(setUuid, promptUuid);
-            renderPromptDetail(prompt);
-        }
-        catch (err) {
-            renderError(err instanceof Error ? err.message : String(err));
-            process.exit(1);
-        }
-    });
-    prompts
-        .command('add <setUuid>')
-        .description('Add a prompt to a prompt set')
-        .requiredOption('--prompt <text>', 'Prompt text')
-        .option('--goal <text>', 'Prompt goal')
-        .action(async (setUuid, opts) => {
-        try {
-            renderRedteamHeader();
-            const service = await createPromptSetService();
-            const result = await service.addPrompt(setUuid, opts.prompt, opts.goal);
-            console.log(`  Prompt added: ${result.uuid}\n`);
-        }
-        catch (err) {
-            renderError(err instanceof Error ? err.message : String(err));
-            process.exit(1);
-        }
-    });
-    prompts
-        .command('update <setUuid> <promptUuid>')
-        .description('Update a prompt')
-        .option('--prompt <text>', 'New prompt text')
-        .option('--goal <text>', 'New goal')
-        .action(async (setUuid, promptUuid, opts) => {
-        try {
-            renderRedteamHeader();
-            const service = await createPromptSetService();
-            const request = {};
-            if (opts.prompt)
-                request.prompt = opts.prompt;
-            if (opts.goal)
-                request.goal = opts.goal;
-            const result = await service.updatePrompt(setUuid, promptUuid, request);
-            renderPromptDetail(result);
-        }
-        catch (err) {
-            renderError(err instanceof Error ? err.message : String(err));
-            process.exit(1);
-        }
-    });
-    prompts
-        .command('delete <setUuid> <promptUuid>')
-        .description('Delete a prompt')
-        .action(async (setUuid, promptUuid) => {
-        try {
-            renderRedteamHeader();
-            const service = await createPromptSetService();
-            await service.deletePrompt(setUuid, promptUuid);
-            console.log(`  Prompt ${promptUuid} deleted.\n`);
-        }
-        catch (err) {
-            renderError(err instanceof Error ? err.message : String(err));
-            process.exit(1);
-        }
-    });
-    // -----------------------------------------------------------------------
-    // redteam properties — property name/value management
-    // -----------------------------------------------------------------------
-    const properties = redteam.command('properties').description('Manage custom attack properties');
-    properties
-        .command('list')
-        .description('List property names')
-        .option('--output <format>', 'Output format: pretty, table, csv, json, yaml', 'pretty')
-        .action(async (opts) => {
-        try {
-            const fmt = opts.output;
-            if (fmt === 'pretty')
-                renderRedteamHeader();
-            const service = await createPromptSetService();
-            const names = await service.getPropertyNames();
-            renderPropertyNames(names, fmt);
-        }
-        catch (err) {
-            renderError(err instanceof Error ? err.message : String(err));
-            process.exit(1);
-        }
-    });
-    properties
-        .command('create')
-        .description('Create a property name')
-        .requiredOption('--name <name>', 'Property name')
-        .action(async (opts) => {
-        try {
-            renderRedteamHeader();
-            const service = await createPromptSetService();
-            const result = await service.createPropertyName(opts.name);
-            console.log(`  Property created: ${result.name}\n`);
-        }
-        catch (err) {
-            renderError(err instanceof Error ? err.message : String(err));
-            process.exit(1);
-        }
-    });
-    properties
-        .command('values <name>')
-        .description('List values for a property')
-        .option('--output <format>', 'Output format: pretty, json, yaml', 'pretty')
-        .action(async (name, opts) => {
-        try {
-            const fmt = opts.output;
-            if (fmt === 'pretty')
-                renderRedteamHeader();
-            const service = await createPromptSetService();
-            const values = await service.getPropertyValues(name);
-            renderPropertyValues(values, fmt);
-        }
-        catch (err) {
-            renderError(err instanceof Error ? err.message : String(err));
-            process.exit(1);
-        }
-    });
-    properties
-        .command('add-value')
-        .description('Create a property value')
-        .requiredOption('--name <name>', 'Property name')
-        .requiredOption('--value <value>', 'Property value')
-        .action(async (opts) => {
-        try {
-            renderRedteamHeader();
-            const service = await createPromptSetService();
-            const result = await service.createPropertyValue(opts.name, opts.value);
-            console.log(`  Value created: ${result.name}=${result.value}\n`);
-        }
-        catch (err) {
-            renderError(err instanceof Error ? err.message : String(err));
-            process.exit(1);
-        }
-    });
-    // -----------------------------------------------------------------------
-    // redteam report — view scan report
-    // -----------------------------------------------------------------------
-    redteam
-        .command('report <jobId>')
-        .description('View scan report')
-        .option('--attacks', 'Include attack list', false)
-        .option('--severity <level>', 'Filter attacks by severity')
-        .option('--limit <n>', 'Max attacks to show', '20')
-        .action(async (jobId, opts) => {
-        try {
-            renderRedteamHeader();
-            const service = await createService();
-            const job = await service.getScan(jobId);
-            renderScanStatus(job);
-            if (job.jobType === 'CUSTOM') {
-                const report = await service.getCustomReport(jobId);
-                renderCustomReport(report);
-                if (opts.attacks) {
-                    const attacks = await service.listCustomAttacks(jobId, {
-                        limit: Number.parseInt(opts.limit, 10),
-                    });
-                    renderCustomAttackList(attacks);
-                }
-            }
-            else {
-                const report = await service.getStaticReport(jobId);
-                renderStaticReport(report);
-                if (opts.attacks) {
-                    const { attacks, totalItems } = await service.listAttacks(jobId, {
-                        severity: opts.severity,
-                        limit: Number.parseInt(opts.limit, 10),
-                    });
-                    const footnote = buildAttackListFootnote({
-                        severity: opts.severity,
-                        totalItems,
-                        severityBreakdown: report.severityBreakdown,
-                    });
-                    renderAttackList(attacks, { footnote });
-                }
-            }
-        }
-        catch (err) {
-            renderError(err instanceof Error ? err.message : String(err));
-            process.exit(1);
-        }
-    });
-    // -----------------------------------------------------------------------
-    // redteam scan — execute a red team scan
-    // -----------------------------------------------------------------------
-    redteam
-        .command('scan')
-        .description('Execute a red team scan against a target')
-        .requiredOption('--target <uuid>', 'Target UUID')
-        .requiredOption('--name <name>', 'Scan name')
-        .option('--type <type>', 'Job type: STATIC, DYNAMIC, or CUSTOM', 'STATIC')
-        .option('--categories <json>', 'Category filter JSON (STATIC scans)')
-        .option('--prompt-sets <uuids>', 'Comma-separated prompt set UUIDs (CUSTOM scans)')
-        .option('--goals <file>', 'JSON file or inline JSON array of attack goals (DYNAMIC scans)')
-        .option('--depth <number>', 'Max conversation turns per goal (DYNAMIC scans)', '10')
-        .option('--breadth <number>', 'Parallel agents per goal (DYNAMIC scans)', '6')
-        .option('--no-wait', 'Submit scan without waiting for completion')
-        .action(async (opts) => {
-        try {
-            renderRedteamHeader();
-            const service = await createService();
-            let categories;
-            if (opts.categories) {
-                categories = JSON.parse(opts.categories);
-            }
-            const customPromptSets = opts.promptSets
-                ? opts.promptSets.split(',').map((s) => s.trim())
-                : undefined;
-            const attackGoals = opts.goals ? parseAttackGoals(opts.goals) : undefined;
-            const streamDepth = parsePositiveInt(opts.depth, '--depth');
-            const streamBreadth = parsePositiveInt(opts.breadth, '--breadth');
-            console.log(`  Creating ${opts.type} scan "${opts.name}"...`);
-            const job = await service.createScan({
-                name: opts.name,
-                targetUuid: opts.target,
-                jobType: opts.type,
-                categories,
-                customPromptSets,
-                attackGoals,
-                streamDepth,
-                streamBreadth,
-            });
-            renderScanStatus(job);
-            if (opts.wait !== false) {
-                console.log('  Waiting for completion...\n');
-                const completed = await service.waitForCompletion(job.uuid, (progress) => renderScanProgress(progress));
-                console.log('\n');
-                renderScanStatus(completed);
-                console.log(`  Job ID: ${completed.uuid}`);
-                console.log('  Run `airs redteam report <jobId>` to view results.\n');
-            }
-            else {
-                console.log(`  Job ID: ${job.uuid}`);
-                console.log('  Run `airs redteam status <jobId>` to check progress.\n');
-            }
-        }
-        catch (err) {
-            renderError(err instanceof Error ? err.message : String(err));
-            process.exit(1);
-        }
-    });
-    // -----------------------------------------------------------------------
-    // redteam status — check scan status
-    // -----------------------------------------------------------------------
-    redteam
-        .command('status <jobId>')
-        .description('Check scan status')
-        .action(async (jobId) => {
-        try {
-            renderRedteamHeader();
-            const service = await createService();
-            const job = await service.getScan(jobId);
-            renderScanStatus(job);
-        }
-        catch (err) {
-            renderError(err instanceof Error ? err.message : String(err));
-            process.exit(1);
-        }
-    });
-    // -----------------------------------------------------------------------
-    // redteam targets — target CRUD subcommands
-    // -----------------------------------------------------------------------
-    const targets = redteam.command('targets').description('Manage red team targets');
-    targets
-        .command('list')
-        .description('List configured red team targets')
-        .option('--output <format>', 'Output format: pretty, table, csv, json, yaml', 'pretty')
-        .action(async (opts) => {
-        try {
-            const fmt = opts.output;
-            if (fmt === 'pretty')
-                renderRedteamHeader();
-            const service = await createService();
-            const list = await service.listTargets();
-            renderTargetList(list, fmt);
-        }
-        catch (err) {
-            renderError(err instanceof Error ? err.message : String(err));
-            process.exit(1);
-        }
-    });
-    targets
-        .command('get <uuid>')
-        .description('Get target details')
-        .option('--output <format>', 'Output format: pretty, json, yaml', 'pretty')
-        .action(async (uuid, opts) => {
-        try {
-            const fmt = opts.output;
-            if (fmt === 'pretty')
-                renderRedteamHeader();
-            const service = await createService();
-            const target = await service.getTarget(uuid);
-            renderTargetDetail(target, fmt);
-        }
-        catch (err) {
-            renderError(err instanceof Error ? err.message : String(err));
-            process.exit(1);
-        }
-    });
-    targets
-        .command('create')
-        .description('Create a new red team target')
-        .requiredOption('--config <path>', 'JSON file with target configuration')
-        .option('--validate', 'Validate target connection before saving')
-        .action(async (opts) => {
-        try {
-            renderRedteamHeader();
-            const service = await createService();
-            const config = JSON.parse(fs.readFileSync(opts.config, 'utf-8'));
-            const target = await service.createTarget(config, opts.validate ? { validate: true } : undefined);
-            console.log(`  Target created: ${target.uuid}\n`);
-            renderTargetDetail(target);
-        }
-        catch (err) {
-            renderError(err instanceof Error ? err.message : String(err));
-            process.exit(1);
-        }
-    });
-    targets
-        .command('update <uuid>')
-        .description('Update a red team target')
-        .requiredOption('--config <path>', 'JSON file with target updates')
-        .option('--validate', 'Validate target connection before saving')
-        .action(async (uuid, opts) => {
-        try {
-            renderRedteamHeader();
-            const service = await createService();
-            const config = JSON.parse(fs.readFileSync(opts.config, 'utf-8'));
-            const target = await service.updateTarget(uuid, config, opts.validate ? { validate: true } : undefined);
-            console.log(`  Target updated: ${target.uuid}\n`);
-            renderTargetDetail(target);
-        }
-        catch (err) {
-            renderError(err instanceof Error ? err.message : String(err));
-            process.exit(1);
-        }
-    });
-    targets
-        .command('delete <uuid>')
-        .description('Delete a red team target')
-        .action(async (uuid) => {
-        try {
-            renderRedteamHeader();
-            const service = await createService();
-            await service.deleteTarget(uuid);
-            console.log(`  Target ${uuid} deleted.\n`);
-        }
-        catch (err) {
-            renderError(err instanceof Error ? err.message : String(err));
-            process.exit(1);
-        }
-    });
-    targets
-        .command('probe')
-        .description('Test target connection without saving')
-        .requiredOption('--config <path>', 'JSON file with connection params')
-        .action(async (opts) => {
-        try {
-            renderRedteamHeader();
-            const service = await createService();
-            const config = JSON.parse(fs.readFileSync(opts.config, 'utf-8'));
-            const result = await service.probeTarget(config);
-            console.log('  Probe result:');
-            console.log(`    ${JSON.stringify(result, null, 2)}\n`);
-        }
-        catch (err) {
-            renderError(err instanceof Error ? err.message : String(err));
-            process.exit(1);
-        }
-    });
-    targets
-        .command('profile <uuid>')
-        .description('View target profile')
-        .action(async (uuid) => {
-        try {
-            renderRedteamHeader();
-            const service = await createService();
-            const profile = await service.getTargetProfile(uuid);
-            console.log('  Target Profile:');
-            console.log(`    ${JSON.stringify(profile, null, 2)}\n`);
-        }
-        catch (err) {
-            renderError(err instanceof Error ? err.message : String(err));
-            process.exit(1);
-        }
-    });
-    targets
-        .command('update-profile <uuid>')
-        .description('Update target profile')
-        .requiredOption('--config <path>', 'JSON file with profile updates')
-        .action(async (uuid, opts) => {
-        try {
-            renderRedteamHeader();
-            const service = await createService();
-            const config = JSON.parse(fs.readFileSync(opts.config, 'utf-8'));
-            const result = await service.updateTargetProfile(uuid, config);
-            console.log('  Profile updated:');
-            console.log(`    ${JSON.stringify(result, null, 2)}\n`);
-        }
-        catch (err) {
-            renderError(err instanceof Error ? err.message : String(err));
-            process.exit(1);
-        }
-    });
-    targets
-        .command('validate-auth')
-        .description('Validate target auth credentials')
-        .requiredOption('--auth-type <type>', 'Auth type: HEADERS, BASIC_AUTH, OAUTH2')
-        .requiredOption('--config <path>', 'JSON file with auth_config')
-        .option('--target-id <uuid>', 'Existing target UUID')
-        .action(async (opts) => {
-        try {
-            renderRedteamHeader();
-            const service = await createService();
-            const authConfig = JSON.parse(fs.readFileSync(opts.config, 'utf-8'));
-            const result = await service.validateTargetAuth({
-                authType: opts.authType,
-                authConfig,
-                targetId: opts.targetId,
-            });
-            renderAuthValidation(result);
-        }
-        catch (err) {
-            renderError(err instanceof Error ? err.message : String(err));
-            process.exit(1);
-        }
-    });
-    targets
-        .command('metadata')
-        .description('Get target field metadata')
-        .action(async () => {
-        try {
-            renderRedteamHeader();
-            const service = await createService();
-            const metadata = await service.getTargetMetadata();
-            console.log(JSON.stringify(metadata, null, 2));
-        }
-        catch (err) {
-            renderError(err instanceof Error ? err.message : String(err));
-            process.exit(1);
-        }
-    });
-    targets
-        .command('init <provider>')
-        .description('Scaffold a target config JSON from a provider template')
-        .option('--output <file>', 'Output file path')
-        .action(async (provider, opts) => {
-        try {
-            renderRedteamHeader();
-            const service = await createService();
-            const templates = await service.getTargetTemplates();
-            const scaffold = buildTargetScaffold(provider, templates);
-            const filename = opts.output ?? `${provider.toLowerCase()}-target.json`;
-            const outputPath = path.resolve(filename);
-            if (fs.existsSync(outputPath)) {
-                renderError(`File already exists: ${outputPath} (use --output to specify a different path)`);
-                process.exit(1);
-            }
-            fs.writeFileSync(outputPath, `${JSON.stringify(scaffold, null, 2)}\n`);
-            console.log(chalk.bold('\n  Target config scaffolded:\n'));
-            console.log(`    File: ${chalk.cyan(outputPath)}`);
-            console.log(`    Provider: ${chalk.dim(provider.toUpperCase())}`);
-            console.log(`\n  ${chalk.yellow('Next steps:')} Edit the file to fill in ${chalk.bold('name')} and credentials, then run:`);
-            console.log(`    ${chalk.cyan(`airs redteam targets create --config ${filename} --validate`)}\n`);
-        }
-        catch (err) {
-            renderError(err instanceof Error ? err.message : String(err));
-            process.exit(1);
-        }
-    });
-    targets
-        .command('templates')
-        .description('Get provider-specific target templates')
-        .action(async () => {
-        try {
-            renderRedteamHeader();
-            const service = await createService();
-            const templates = await service.getTargetTemplates();
-            renderTargetTemplates(templates);
-        }
-        catch (err) {
-            renderError(err instanceof Error ? err.message : String(err));
-            process.exit(1);
-        }
-    });
-    targets
-        .command('backup')
-        .description('Backup red team targets to local JSON/YAML files')
-        .option('--output-dir <path>', 'Output directory')
-        .option('--format <format>', 'Output format: json or yaml', 'json')
-        .option('--name <targetName>', 'Backup a single target by name')
-        .action(async (opts) => {
-        try {
-            renderBackupHeader();
-            const outputDir = resolveOutputDir(opts.outputDir, 'targets');
-            const results = await backupTargets({
-                outputDir,
-                format: (opts.format ?? 'json'),
-                name: opts.name,
-            });
-            renderBackupSummary(results, outputDir);
-            const failed = results.filter((r) => r.status === 'failed').length;
-            if (failed > 0)
-                process.exit(1);
-        }
-        catch (err) {
-            renderError(err instanceof Error ? err.message : String(err));
-            process.exit(1);
-        }
-    });
-    targets
-        .command('restore')
-        .description('Restore red team targets from local JSON/YAML backup files')
-        .option('--input-dir <path>', 'Directory containing backup files')
-        .option('--file <path>', 'Single backup file to restore')
-        .option('--overwrite', 'Update existing targets with same name (default: skip)')
-        .option('--validate', 'Validate target connection before saving')
-        .action(async (opts) => {
-        try {
-            renderBackupHeader();
-            if (!opts.file && !opts.inputDir) {
-                throw new Error('Specify --file <path> or --input-dir <path>');
-            }
-            const results = await restoreTargets({
-                file: opts.file,
-                inputDir: opts.inputDir,
-                overwrite: opts.overwrite,
-                validate: opts.validate,
-            });
-            renderRestoreSummary(results);
-            const failed = results.filter((r) => r.action === 'failed').length;
-            if (failed > 0)
-                process.exit(1);
-        }
-        catch (err) {
-            renderError(err instanceof Error ? err.message : String(err));
-            process.exit(1);
-        }
-    });
-}
-//# sourceMappingURL=redteam.js.map