feat: v2.1.0 核心重构与功能增强

## 架构重构
- 全局变量消除，迁移至 Config/State 对象
- SMB 插件融合（smb/smb2/smbghost/smbinfo）
- 服务探测重构，实现 Nmap 风格 fallback 机制
- 输出系统重构，TXT 实时刷盘 + 双写机制
- i18n 框架升级至 go-i18n

## 性能优化
- 正则表达式预编译
- 内存优化 map[string]struct{}
- 并发指纹匹配
- SOCKS5 连接复用
- 滑动窗口调度 + 自适应线程池

## 新功能
- Web 管理界面
- 多格式 POC 适配（xray/afrog）
- 增强指纹库（3139条）
- Favicon hash 指纹识别
- 插件选择性编译（Build Tags）
- fscan-lab 靶场环境
- 默认端口扩展（62→133）

## 构建系统
- 添加 no_local tag 支持排除本地插件
- 多版本构建：fscan/fscan-nolocal/fscan-web
- CI 添加 snapshot 模式支持仅测试构建

## Bug 修复
- 修复 120+ 个问题，包括 RDP panic、批量扫描漏报、
  JSON 输出格式、Redis 检测、Context 超时等

## 测试增强
- 单元测试覆盖率 74-100%
- 并发安全测试
- 集成测试（Web/端口/服务/SSH/ICMP）

common/output/buffer.go

@@ -0,0 +1,160 @@
+package output
+
+import (
+	"fmt"
+	"sync"
+)
+
+// ResultBuffer 公共的去重缓冲逻辑，供各Writer复用
+type ResultBuffer struct {
+	mu sync.Mutex
+
+	// 分类缓冲
+	HostResults    []*ScanResult
+	PortResults    []*ScanResult
+	ServiceResults []*ScanResult
+	VulnResults    []*ScanResult
+
+	// 去重map
+	seenHosts    map[string]struct{}
+	seenPorts    map[string]struct{}
+	seenServices map[string]int // 存储索引，用于更新更完整的记录
+	seenVulns    map[string]struct{}
+}
+
+// NewResultBuffer 创建新的结果缓冲
+func NewResultBuffer() *ResultBuffer {
+	return &ResultBuffer{
+		seenHosts:    make(map[string]struct{}),
+		seenPorts:    make(map[string]struct{}),
+		seenServices: make(map[string]int),
+		seenVulns:    make(map[string]struct{}),
+	}
+}
+
+// Add 添加结果到缓冲（自动去重）
+func (b *ResultBuffer) Add(result *ScanResult) {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+
+	if result == nil {
+		return
+	}
+
+	key := b.generateKey(result)
+
+	switch result.Type {
+	case TypeHost:
+		if _, exists := b.seenHosts[key]; !exists {
+			b.seenHosts[key] = struct{}{}
+			b.HostResults = append(b.HostResults, result)
+		}
+	case TypePort:
+		if _, exists := b.seenPorts[key]; !exists {
+			b.seenPorts[key] = struct{}{}
+			b.PortResults = append(b.PortResults, result)
+		}
+	case TypeService:
+		if idx, exists := b.seenServices[key]; !exists {
+			b.seenServices[key] = len(b.ServiceResults)
+			b.ServiceResults = append(b.ServiceResults, result)
+		} else {
+			// 保留信息更完整的记录
+			if b.isMoreComplete(result, b.ServiceResults[idx]) {
+				b.ServiceResults[idx] = result
+			}
+		}
+	case TypeVuln:
+		if _, exists := b.seenVulns[key]; !exists {
+			b.seenVulns[key] = struct{}{}
+			b.VulnResults = append(b.VulnResults, result)
+		}
+	}
+}
+
+// generateKey 生成结果的唯一键（用于去重）
+func (b *ResultBuffer) generateKey(result *ScanResult) string {
+	switch result.Type {
+	case TypeHost:
+		return result.Target
+	case TypePort:
+		if result.Details != nil {
+			if port, ok := result.Details["port"]; ok {
+				return fmt.Sprintf("%s:%v", result.Target, port)
+			}
+		}
+		return result.Target
+	case TypeService:
+		return result.Target
+	case TypeVuln:
+		return result.Target + "|" + result.Status
+	default:
+		return result.Target + "|" + result.Status
+	}
+}
+
+// isMoreComplete 判断新记录是否比旧记录信息更完整
+func (b *ResultBuffer) isMoreComplete(newResult, oldResult *ScanResult) bool {
+	return b.CalculateCompleteness(newResult) > b.CalculateCompleteness(oldResult)
+}
+
+// CalculateCompleteness 计算记录的信息完整度
+func (b *ResultBuffer) CalculateCompleteness(result *ScanResult) int {
+	score := 0
+	if result.Details == nil {
+		return score
+	}
+
+	// 有 status 码加分
+	if status, ok := result.Details["status"]; ok && status != nil && status != 0 {
+		score += 2
+	}
+	// 有 server 加分
+	if server, ok := result.Details["server"].(string); ok && server != "" {
+		score += 2
+	}
+	// 有 title 加分
+	if title, ok := result.Details["title"].(string); ok && title != "" {
+		score += 1
+	}
+	// 有指纹加分
+	if fps := result.Details["fingerprints"]; fps != nil {
+		switch v := fps.(type) {
+		case []string:
+			if len(v) > 0 {
+				score += 3
+			}
+		case []interface{}:
+			if len(v) > 0 {
+				score += 3
+			}
+		}
+	}
+	// 有 banner 加分
+	if banner, ok := result.Details["banner"].(string); ok && banner != "" {
+		score += 1
+	}
+
+	return score
+}
+
+// Summary 获取统计摘要
+func (b *ResultBuffer) Summary() (hosts, ports, services, vulns int) {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	return len(b.HostResults), len(b.PortResults), len(b.ServiceResults), len(b.VulnResults)
+}
+
+// Clear 清空缓冲
+func (b *ResultBuffer) Clear() {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	b.HostResults = nil
+	b.PortResults = nil
+	b.ServiceResults = nil
+	b.VulnResults = nil
+	b.seenHosts = make(map[string]struct{})
+	b.seenPorts = make(map[string]struct{})
+	b.seenServices = make(map[string]int)
+	b.seenVulns = make(map[string]struct{})
+}

common/output/buffer_test.go

@@ -0,0 +1,441 @@
+package output
+
+import (
+	"fmt"
+	"sync"
+	"testing"
+)
+
+/*
+buffer_test.go - ResultBuffer 高价值测试
+
+测试重点：
+1. 去重逻辑 - 不同结果类型的去重策略差异
+2. 完整度评分 - 决定是否替换已有服务记录
+3. 并发安全 - 多goroutine同时Add
+*/
+
+// =============================================================================
+// 基本去重测试
+// =============================================================================
+
+// TestResultBuffer_HostDeduplication 测试主机去重
+func TestResultBuffer_HostDeduplication(t *testing.T) {
+	buf := NewResultBuffer()
+
+	// 添加相同主机多次
+	for i := 0; i < 10; i++ {
+		buf.Add(&ScanResult{
+			Type:   TypeHost,
+			Target: "192.168.1.1",
+			Status: "alive",
+		})
+	}
+
+	hosts, _, _, _ := buf.Summary()
+	if hosts != 1 {
+		t.Errorf("主机应去重为1个，实际 %d", hosts)
+	}
+}
+
+// TestResultBuffer_PortDeduplication 测试端口去重
+func TestResultBuffer_PortDeduplication(t *testing.T) {
+	buf := NewResultBuffer()
+
+	// 相同IP:Port应去重
+	for i := 0; i < 5; i++ {
+		buf.Add(&ScanResult{
+			Type:    TypePort,
+			Target:  "192.168.1.1",
+			Details: map[string]interface{}{"port": 80},
+		})
+	}
+
+	// 不同端口不去重
+	buf.Add(&ScanResult{
+		Type:    TypePort,
+		Target:  "192.168.1.1",
+		Details: map[string]interface{}{"port": 443},
+	})
+
+	_, ports, _, _ := buf.Summary()
+	if ports != 2 {
+		t.Errorf("端口应有2个（80和443），实际 %d", ports)
+	}
+}
+
+// TestResultBuffer_ServiceDeduplication 测试服务去重
+func TestResultBuffer_ServiceDeduplication(t *testing.T) {
+	buf := NewResultBuffer()
+
+	// 相同Target的服务应去重
+	buf.Add(&ScanResult{
+		Type:   TypeService,
+		Target: "192.168.1.1:80",
+		Status: "http",
+	})
+	buf.Add(&ScanResult{
+		Type:   TypeService,
+		Target: "192.168.1.1:80",
+		Status: "nginx",
+	})
+
+	_, _, services, _ := buf.Summary()
+	if services != 1 {
+		t.Errorf("相同Target的服务应去重为1个，实际 %d", services)
+	}
+}
+
+// TestResultBuffer_VulnDeduplication 测试漏洞去重
+func TestResultBuffer_VulnDeduplication(t *testing.T) {
+	buf := NewResultBuffer()
+
+	// 相同Target+Status的漏洞应去重
+	for i := 0; i < 3; i++ {
+		buf.Add(&ScanResult{
+			Type:   TypeVuln,
+			Target: "192.168.1.1:445",
+			Status: "MS17-010",
+		})
+	}
+
+	// 不同漏洞不去重
+	buf.Add(&ScanResult{
+		Type:   TypeVuln,
+		Target: "192.168.1.1:445",
+		Status: "CVE-2020-0796",
+	})
+
+	_, _, _, vulns := buf.Summary()
+	if vulns != 2 {
+		t.Errorf("漏洞应有2个，实际 %d", vulns)
+	}
+}
+
+// =============================================================================
+// 完整度评分测试
+// =============================================================================
+
+// TestResultBuffer_CompletenessScore 测试完整度评分
+func TestResultBuffer_CompletenessScore(t *testing.T) {
+	buf := NewResultBuffer()
+
+	tests := []struct {
+		name          string
+		result        *ScanResult
+		expectedScore int
+	}{
+		{
+			name:          "空Details",
+			result:        &ScanResult{Details: nil},
+			expectedScore: 0,
+		},
+		{
+			name:          "只有status",
+			result:        &ScanResult{Details: map[string]interface{}{"status": 200}},
+			expectedScore: 2,
+		},
+		{
+			name:          "有server",
+			result:        &ScanResult{Details: map[string]interface{}{"server": "nginx/1.18.0"}},
+			expectedScore: 2,
+		},
+		{
+			name:          "有title",
+			result:        &ScanResult{Details: map[string]interface{}{"title": "Welcome"}},
+			expectedScore: 1,
+		},
+		{
+			name:          "有指纹-[]string",
+			result:        &ScanResult{Details: map[string]interface{}{"fingerprints": []string{"nginx"}}},
+			expectedScore: 3,
+		},
+		{
+			name:          "有指纹-[]interface{}",
+			result:        &ScanResult{Details: map[string]interface{}{"fingerprints": []interface{}{"apache", "php"}}},
+			expectedScore: 3,
+		},
+		{
+			name:          "有banner",
+			result:        &ScanResult{Details: map[string]interface{}{"banner": "SSH-2.0-OpenSSH"}},
+			expectedScore: 1,
+		},
+		{
+			name: "完整记录",
+			result: &ScanResult{
+				Details: map[string]interface{}{
+					"status":       200,
+					"server":       "nginx",
+					"title":        "Home",
+					"fingerprints": []string{"nginx", "php"},
+					"banner":       "test",
+				},
+			},
+			expectedScore: 9, // 2+2+1+3+1
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			score := buf.CalculateCompleteness(tt.result)
+			if score != tt.expectedScore {
+				t.Errorf("完整度评分 = %d, 期望 %d", score, tt.expectedScore)
+			}
+		})
+	}
+}
+
+// TestResultBuffer_ServiceUpdate 测试服务记录更新
+//
+// 当新记录比旧记录更完整时，应该替换
+func TestResultBuffer_ServiceUpdate(t *testing.T) {
+	buf := NewResultBuffer()
+
+	// 先添加简单记录
+	buf.Add(&ScanResult{
+		Type:    TypeService,
+		Target:  "192.168.1.1:80",
+		Status:  "http",
+		Details: map[string]interface{}{},
+	})
+
+	// 再添加更完整的记录
+	buf.Add(&ScanResult{
+		Type:   TypeService,
+		Target: "192.168.1.1:80",
+		Status: "http",
+		Details: map[string]interface{}{
+			"status":       200,
+			"server":       "nginx/1.18.0",
+			"title":        "Welcome",
+			"fingerprints": []string{"nginx", "php"},
+		},
+	})
+
+	_, _, services, _ := buf.Summary()
+	if services != 1 {
+		t.Fatal("服务数量应为1")
+	}
+
+	// 验证是更完整的记录
+	if buf.ServiceResults[0].Details == nil {
+		t.Fatal("Details不应为nil")
+	}
+	if buf.ServiceResults[0].Details["server"] != "nginx/1.18.0" {
+		t.Error("应保留更完整的记录")
+	}
+}
+
+// TestResultBuffer_ServiceNoDowngrade 测试不降级服务记录
+//
+// 当新记录不如旧记录完整时，不应替换
+func TestResultBuffer_ServiceNoDowngrade(t *testing.T) {
+	buf := NewResultBuffer()
+
+	// 先添加完整记录
+	buf.Add(&ScanResult{
+		Type:   TypeService,
+		Target: "192.168.1.1:80",
+		Status: "http",
+		Details: map[string]interface{}{
+			"status":       200,
+			"server":       "nginx/1.18.0",
+			"fingerprints": []string{"nginx"},
+		},
+	})
+
+	// 再添加简单记录
+	buf.Add(&ScanResult{
+		Type:    TypeService,
+		Target:  "192.168.1.1:80",
+		Status:  "http",
+		Details: map[string]interface{}{},
+	})
+
+	// 验证仍保留完整记录
+	if buf.ServiceResults[0].Details["server"] != "nginx/1.18.0" {
+		t.Error("不应降级到不完整的记录")
+	}
+}
+
+// =============================================================================
+// 并发安全测试
+// =============================================================================
+
+// TestResultBuffer_ConcurrentAdd 测试并发添加
+func TestResultBuffer_ConcurrentAdd(t *testing.T) {
+	buf := NewResultBuffer()
+
+	const goroutines = 100
+	const resultsPerGoroutine = 100
+
+	var wg sync.WaitGroup
+	wg.Add(goroutines)
+
+	for i := 0; i < goroutines; i++ {
+		go func(id int) {
+			defer wg.Done()
+			for j := 0; j < resultsPerGoroutine; j++ {
+				// 每个goroutine添加不同类型的结果
+				switch j % 4 {
+				case 0:
+					buf.Add(&ScanResult{
+						Type:   TypeHost,
+						Target: fmt.Sprintf("192.168.%d.%d", id, j),
+					})
+				case 1:
+					buf.Add(&ScanResult{
+						Type:    TypePort,
+						Target:  fmt.Sprintf("192.168.%d.%d", id, j),
+						Details: map[string]interface{}{"port": j},
+					})
+				case 2:
+					buf.Add(&ScanResult{
+						Type:   TypeService,
+						Target: fmt.Sprintf("192.168.%d.%d:%d", id, j, j),
+					})
+				case 3:
+					buf.Add(&ScanResult{
+						Type:   TypeVuln,
+						Target: fmt.Sprintf("192.168.%d.%d", id, j),
+						Status: fmt.Sprintf("CVE-%d", j),
+					})
+				}
+			}
+		}(i)
+	}
+
+	wg.Wait()
+
+	// 验证没有panic，数据完整
+	hosts, ports, services, vulns := buf.Summary()
+	total := hosts + ports + services + vulns
+
+	if total == 0 {
+		t.Error("并发添加后应有结果")
+	}
+
+	t.Logf("并发测试完成: %d hosts, %d ports, %d services, %d vulns",
+		hosts, ports, services, vulns)
+}
+
+// TestResultBuffer_ConcurrentSummary 测试并发获取摘要
+func TestResultBuffer_ConcurrentSummary(t *testing.T) {
+	buf := NewResultBuffer()
+
+	// 预填充一些数据
+	for i := 0; i < 100; i++ {
+		buf.Add(&ScanResult{
+			Type:   TypeHost,
+			Target: fmt.Sprintf("192.168.1.%d", i),
+		})
+	}
+
+	var wg sync.WaitGroup
+	wg.Add(100)
+
+	for i := 0; i < 100; i++ {
+		go func() {
+			defer wg.Done()
+			// 同时获取摘要和添加
+			buf.Summary()
+			buf.Add(&ScanResult{
+				Type:   TypeHost,
+				Target: "10.0.0.1",
+			})
+		}()
+	}
+
+	wg.Wait()
+	// 没有panic即为成功
+}
+
+// =============================================================================
+// 边界情况测试
+// =============================================================================
+
+// TestResultBuffer_NilResult 测试nil结果
+func TestResultBuffer_NilResult(t *testing.T) {
+	buf := NewResultBuffer()
+	buf.Add(nil) // 不应panic
+
+	hosts, ports, services, vulns := buf.Summary()
+	if hosts+ports+services+vulns != 0 {
+		t.Error("添加nil后应无结果")
+	}
+}
+
+// TestResultBuffer_PortWithoutDetails 测试无Details的端口
+func TestResultBuffer_PortWithoutDetails(t *testing.T) {
+	buf := NewResultBuffer()
+
+	buf.Add(&ScanResult{
+		Type:    TypePort,
+		Target:  "192.168.1.1",
+		Details: nil,
+	})
+
+	_, ports, _, _ := buf.Summary()
+	if ports != 1 {
+		t.Error("无Details的端口也应被添加")
+	}
+}
+
+// TestResultBuffer_Clear 测试清空
+func TestResultBuffer_Clear(t *testing.T) {
+	buf := NewResultBuffer()
+
+	// 添加各类结果
+	buf.Add(&ScanResult{Type: TypeHost, Target: "192.168.1.1"})
+	buf.Add(&ScanResult{Type: TypePort, Target: "192.168.1.1", Details: map[string]interface{}{"port": 80}})
+	buf.Add(&ScanResult{Type: TypeService, Target: "192.168.1.1:80"})
+	buf.Add(&ScanResult{Type: TypeVuln, Target: "192.168.1.1", Status: "CVE-2021-1234"})
+
+	// 清空
+	buf.Clear()
+
+	hosts, ports, services, vulns := buf.Summary()
+	if hosts+ports+services+vulns != 0 {
+		t.Error("Clear后应无结果")
+	}
+
+	// 验证可以继续添加
+	buf.Add(&ScanResult{Type: TypeHost, Target: "10.0.0.1"})
+	hosts, _, _, _ = buf.Summary()
+	if hosts != 1 {
+		t.Error("Clear后应能继续添加")
+	}
+}
+
+// TestResultBuffer_EmptyFingerprints 测试空指纹数组
+func TestResultBuffer_EmptyFingerprints(t *testing.T) {
+	buf := NewResultBuffer()
+
+	// 空字符串数组
+	score1 := buf.CalculateCompleteness(&ScanResult{
+		Details: map[string]interface{}{"fingerprints": []string{}},
+	})
+	if score1 != 0 {
+		t.Errorf("空指纹数组不应加分，实际 %d", score1)
+	}
+
+	// 空interface数组
+	score2 := buf.CalculateCompleteness(&ScanResult{
+		Details: map[string]interface{}{"fingerprints": []interface{}{}},
+	})
+	if score2 != 0 {
+		t.Errorf("空interface数组不应加分，实际 %d", score2)
+	}
+}
+
+// TestResultBuffer_StatusZero 测试status为0
+func TestResultBuffer_StatusZero(t *testing.T) {
+	buf := NewResultBuffer()
+
+	score := buf.CalculateCompleteness(&ScanResult{
+		Details: map[string]interface{}{"status": 0},
+	})
+	if score != 0 {
+		t.Errorf("status为0不应加分，实际 %d", score)
+	}
+}

common/output/constants.go

@@ -0,0 +1,58 @@
+package output
+
+import (
+	"os"
+)
+
+// =============================================================================
+// 输出格式常量
+// =============================================================================
+
+// Format 输出格式类型
+type Format string
+
+const (
+	// FormatTXT 文本格式输出
+	FormatTXT Format = "txt"
+	// FormatJSON JSON格式输出
+	FormatJSON Format = "json"
+	// FormatCSV CSV格式输出
+	FormatCSV Format = "csv"
+)
+
+// =============================================================================
+// 结果类型常量
+// =============================================================================
+
+// ResultType 定义结果类型
+type ResultType string
+
+const (
+	// TypeHost 主机存活
+	TypeHost ResultType = "HOST"
+	// TypePort 端口开放
+	TypePort ResultType = "PORT"
+	// TypeService 服务识别
+	TypeService ResultType = "SERVICE"
+	// TypeVuln 漏洞发现
+	TypeVuln ResultType = "VULN"
+)
+
+// =============================================================================
+// 文件操作常量
+// =============================================================================
+
+const (
+	// DefaultFilePermissions 文件操作权限
+	DefaultFilePermissions = 0644
+	// DefaultDirPermissions 目录操作权限
+	DefaultDirPermissions = 0755
+
+	// DefaultFileFlags 文件打开标志
+	DefaultFileFlags = os.O_CREATE | os.O_WRONLY | os.O_APPEND
+
+	// JSONIndentPrefix JSON格式化前缀
+	JSONIndentPrefix = ""
+	// JSONIndentString JSON格式化缩进字符串
+	JSONIndentString = "  "
+)

common/output/manager.go

@@ -0,0 +1,113 @@
+package output
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"sync"
+)
+
+// Manager 简化的输出管理器
+type Manager struct {
+	mu     sync.RWMutex
+	config *ManagerConfig
+	writer Writer
+	closed bool
+}
+
+// NewManager 创建新的输出管理器
+func NewManager(config *ManagerConfig) (*Manager, error) {
+	if config == nil {
+		return nil, fmt.Errorf("output config cannot be nil")
+	}
+
+	// 创建输出目录
+	if err := createOutputDir(config.OutputPath); err != nil {
+		return nil, err
+	}
+
+	manager := &Manager{
+		config: config,
+	}
+
+	// 初始化写入器（内部会验证格式）
+	if err := manager.initializeWriter(); err != nil {
+		return nil, err
+	}
+
+	return manager, nil
+}
+
+// createOutputDir 创建输出目录
+func createOutputDir(outputPath string) error {
+	dir := filepath.Dir(outputPath)
+	return os.MkdirAll(dir, DefaultDirPermissions)
+}
+
+// initializeWriter 初始化写入器
+func (m *Manager) initializeWriter() error {
+	var writer Writer
+	var err error
+
+	switch m.config.Format {
+	case FormatTXT:
+		writer, err = NewTXTWriter(m.config.OutputPath)
+	case FormatJSON:
+		writer, err = NewJSONWriter(m.config.OutputPath)
+	case FormatCSV:
+		writer, err = NewCSVWriter(m.config.OutputPath)
+	default:
+		return fmt.Errorf("unsupported format: %s", m.config.Format)
+	}
+
+	if err != nil {
+		return err
+	}
+
+	m.writer = writer
+	return m.writer.WriteHeader()
+}
+
+// SaveResult 保存扫描结果
+func (m *Manager) SaveResult(result *ScanResult) error {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+
+	if m.closed {
+		return fmt.Errorf("output manager is closed")
+	}
+
+	if result == nil {
+		return fmt.Errorf("result cannot be nil")
+	}
+
+	return m.writer.Write(result)
+}
+
+// Flush 刷新输出
+func (m *Manager) Flush() error {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+
+	if m.closed {
+		return fmt.Errorf("output manager is closed")
+	}
+
+	return m.writer.Flush()
+}
+
+// Close 关闭输出管理器
+func (m *Manager) Close() error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	if m.closed {
+		return nil
+	}
+
+	m.closed = true
+	if m.writer != nil {
+		return m.writer.Close()
+	}
+	return nil
+}

common/output/types.go

@@ -0,0 +1,59 @@
+package output
+
+import (
+	"fmt"
+	"sort"
+	"strings"
+	"time"
+)
+
+// ScanResult 扫描结果结构
+type ScanResult struct {
+	Time    time.Time              `json:"time"`    // 发现时间
+	Type    ResultType             `json:"type"`    // 结果类型
+	Target  string                 `json:"target"`  // 目标(IP/域名/URL)
+	Status  string                 `json:"status"`  // 状态描述
+	Details map[string]interface{} `json:"details"` // 详细信息
+}
+
+// FormatDetails 格式化Details为键值对字符串（排序key以保证输出稳定）
+func (r *ScanResult) FormatDetails(separator, kvFormat string) string {
+	if len(r.Details) == 0 {
+		return ""
+	}
+
+	keys := make([]string, 0, len(r.Details))
+	for key := range r.Details {
+		keys = append(keys, key)
+	}
+	sort.Strings(keys)
+
+	pairs := make([]string, 0, len(keys))
+	for _, key := range keys {
+		pairs = append(pairs, fmt.Sprintf(kvFormat, key, r.Details[key]))
+	}
+	return strings.Join(pairs, separator)
+}
+
+// Writer 输出写入器接口
+type Writer interface {
+	Write(result *ScanResult) error
+	WriteHeader() error
+	Flush() error
+	Close() error
+	GetFormat() Format
+}
+
+// ManagerConfig 输出管理器配置
+type ManagerConfig struct {
+	OutputPath string `json:"output_path"` // 输出路径
+	Format     Format `json:"format"`      // 输出格式
+}
+
+// DefaultManagerConfig 默认管理器配置
+func DefaultManagerConfig(outputPath string, format Format) *ManagerConfig {
+	return &ManagerConfig{
+		OutputPath: outputPath,
+		Format:     format,
+	}
+}

common/output/writers.go

@@ -0,0 +1,740 @@
+package output
+
+import (
+	"bufio"
+	"encoding/csv"
+	"encoding/json"
+	"fmt"
+	"os"
+	"strings"
+	"sync"
+	"time"
+)
+
+// escapeControlChars 转义控制字符
+func escapeControlChars(s string) string {
+	replacer := strings.NewReplacer(
+		"\r\n", "\\r\\n",
+		"\n", "\\n",
+		"\r", "\\r",
+		"\t", "\\t",
+	)
+	return replacer.Replace(s)
+}
+
+// =============================================================================
+// TXTWriter - 文本格式写入器
+// =============================================================================
+
+// TXTWriter 文本格式写入器（分类缓冲，按类型聚合输出）
+type TXTWriter struct {
+	file         *os.File
+	bufWriter    *bufio.Writer
+	mu           sync.Mutex
+	closed       bool
+	buffer       *ResultBuffer // 内存分类缓冲
+	realtimeFile *os.File      // 实时备份文件
+	realtimePath string        // 实时备份文件路径
+}
+
+// NewTXTWriter 创建文本写入器
+func NewTXTWriter(filePath string) (*TXTWriter, error) {
+	file, err := os.OpenFile(filePath, DefaultFileFlags, DefaultFilePermissions)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create TXT file: %w", err)
+	}
+
+	// 创建实时备份文件（防崩溃丢数据）
+	realtimePath := filePath + ".realtime.tmp"
+	realtimeFile, err := os.OpenFile(realtimePath, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, DefaultFilePermissions)
+	if err != nil {
+		file.Close()
+		return nil, fmt.Errorf("failed to create realtime backup file: %w", err)
+	}
+
+	return &TXTWriter{
+		file:         file,
+		bufWriter:    bufio.NewWriter(file),
+		buffer:       NewResultBuffer(),
+		realtimeFile: realtimeFile,
+		realtimePath: realtimePath,
+	}, nil
+}
+
+// WriteHeader 写入头部
+func (w *TXTWriter) WriteHeader() error {
+	return nil
+}
+
+// Write 收集扫描结果到分类缓冲，同时实时备份
+func (w *TXTWriter) Write(result *ScanResult) error {
+	w.mu.Lock()
+	defer w.mu.Unlock()
+
+	if w.closed {
+		return fmt.Errorf("writer is closed")
+	}
+	if result == nil {
+		return fmt.Errorf("result cannot be nil")
+	}
+
+	// 1. 加入内存分类缓冲（用于最终有序输出）
+	w.buffer.Add(result)
+
+	// 2. 实时写入备份文件（防崩溃丢数据）
+	if w.realtimeFile != nil {
+		line := w.formatLine(result)
+		if _, err := w.realtimeFile.WriteString(line + "\n"); err != nil {
+			return fmt.Errorf("failed to write realtime backup: %w", err)
+		}
+		if err := w.realtimeFile.Sync(); err != nil {
+			return fmt.Errorf("failed to sync realtime backup: %w", err)
+		}
+	}
+
+	return nil
+}
+
+// getSeparator 获取分隔线文本
+func (w *TXTWriter) getSeparator(newType ResultType) string {
+	switch newType {
+	case TypeHost:
+		return "# ===== 存活主机 ====="
+	case TypePort:
+		return "# ===== 开放端口 ====="
+	case TypeService:
+		return "# ===== 服务信息 ====="
+	case TypeVuln:
+		return "# ===== 漏洞信息 ====="
+	default:
+		return "# ===================="
+	}
+}
+
+// formatLine 根据结果类型格式化输出行
+func (w *TXTWriter) formatLine(result *ScanResult) string {
+	switch result.Type {
+	case TypeHost:
+		return result.Target
+	case TypePort:
+		port := w.getDetail(result, "port")
+		if port != nil {
+			return fmt.Sprintf("%s:%v", result.Target, port)
+		}
+		return result.Target
+	case TypeService:
+		return w.formatServiceLine(result)
+	case TypeVuln:
+		return w.formatVulnLine(result)
+	default:
+		return result.Target
+	}
+}
+
+// formatServiceLine 格式化服务识别结果
+func (w *TXTWriter) formatServiceLine(result *ScanResult) string {
+	service := w.getDetailStr(result, "service")
+	banner := w.getDetailStr(result, "banner")
+
+	// 判断是否为Web服务
+	isWebFlag := false
+	if v, ok := w.getDetail(result, "is_web").(bool); ok && v {
+		isWebFlag = true
+	}
+	if !isWebFlag {
+		if w.getDetail(result, "status") != nil || w.getDetailStr(result, "server") != "" {
+			isWebFlag = true
+		}
+	}
+
+	if isWebFlag || service == "http" || service == "https" {
+		return w.formatWebServiceLine(result)
+	}
+
+	// 非Web服务：ip:port service banner
+	target := result.Target
+	if !strings.Contains(target, ":") {
+		if port := w.getDetail(result, "port"); port != nil {
+			target = fmt.Sprintf("%s:%v", target, port)
+		}
+	}
+
+	var parts []string
+	parts = append(parts, target)
+	if service != "" {
+		parts = append(parts, service)
+	}
+	if banner != "" {
+		if len(banner) > 100 {
+			banner = banner[:100] + "..."
+		}
+		banner = escapeControlChars(banner)
+		parts = append(parts, banner)
+	}
+	return strings.Join(parts, " ")
+}
+
+// formatWebServiceLine 格式化Web服务结果
+func (w *TXTWriter) formatWebServiceLine(result *ScanResult) string {
+	target := result.Target
+	if !strings.Contains(target, ":") {
+		if port := w.getDetail(result, "port"); port != nil {
+			target = fmt.Sprintf("%s:%v", target, port)
+		}
+	}
+
+	protocol := "http"
+	service := w.getDetailStr(result, "service")
+	if service == "https" || strings.Contains(target, ":443") {
+		protocol = "https"
+	}
+
+	url := fmt.Sprintf("%s://%s", protocol, target)
+	title := w.getDetailStr(result, "title")
+	status := w.getDetail(result, "status")
+	server := w.getDetailStr(result, "server")
+	fingerprints := w.getFingerprints(result)
+
+	var parts []string
+	parts = append(parts, url)
+	if title != "" {
+		parts = append(parts, fmt.Sprintf("[%s]", title))
+	}
+	if status != nil && status != 0 {
+		parts = append(parts, fmt.Sprintf("%v", status))
+	}
+	if server != "" {
+		parts = append(parts, server)
+	}
+	if len(fingerprints) > 0 {
+		parts = append(parts, fingerprints)
+	}
+	return strings.Join(parts, " ")
+}
+
+// getFingerprints 获取指纹信息并格式化
+func (w *TXTWriter) getFingerprints(result *ScanResult) string {
+	fp := w.getDetail(result, "fingerprints")
+	if fp == nil {
+		return ""
+	}
+
+	switch v := fp.(type) {
+	case []string:
+		if len(v) > 0 {
+			return "[" + strings.Join(v, ",") + "]"
+		}
+	case []interface{}:
+		if len(v) > 0 {
+			var fps []string
+			for _, f := range v {
+				fps = append(fps, fmt.Sprintf("%v", f))
+			}
+			return "[" + strings.Join(fps, ",") + "]"
+		}
+	}
+	return ""
+}
+
+// formatVulnLine 格式化漏洞发现结果
+func (w *TXTWriter) formatVulnLine(result *ScanResult) string {
+	vulnType := w.getDetailStr(result, "type")
+
+	if vulnType == "weak_credential" {
+		username := w.getDetailStr(result, "username")
+		password := w.getDetailStr(result, "password")
+		service := w.getDetailStr(result, "service")
+
+		if service != "" {
+			return fmt.Sprintf("%s %s %s/%s", result.Target, service, username, password)
+		}
+		return fmt.Sprintf("%s %s/%s", result.Target, username, password)
+	}
+
+	vuln := w.getDetailStr(result, "vulnerability")
+	if vuln != "" {
+		return fmt.Sprintf("%s %s", result.Target, vuln)
+	}
+	return fmt.Sprintf("%s %s", result.Target, result.Status)
+}
+
+// getDetail 获取详情字段值
+func (w *TXTWriter) getDetail(result *ScanResult, key string) interface{} {
+	if result.Details == nil {
+		return nil
+	}
+	return result.Details[key]
+}
+
+// getDetailStr 获取详情字段字符串值
+func (w *TXTWriter) getDetailStr(result *ScanResult, key string) string {
+	val := w.getDetail(result, key)
+	if val == nil {
+		return ""
+	}
+	if s, ok := val.(string); ok {
+		return s
+	}
+	return fmt.Sprintf("%v", val)
+}
+
+// Flush 刷新写入器
+func (w *TXTWriter) Flush() error {
+	w.mu.Lock()
+	defer w.mu.Unlock()
+
+	if w.closed {
+		return nil
+	}
+
+	if err := w.bufWriter.Flush(); err != nil {
+		return err
+	}
+	return w.file.Sync()
+}
+
+// Close 关闭写入器（清理资源，删除临时备份）
+func (w *TXTWriter) Close() error {
+	w.mu.Lock()
+	defer w.mu.Unlock()
+
+	if w.closed {
+		return nil
+	}
+
+	// 按顺序写入所有分类结果
+	w.writeSection(TypeHost, w.buffer.HostResults)
+	w.writeSection(TypePort, w.buffer.PortResults)
+	w.writeSection(TypeService, w.buffer.ServiceResults)
+	w.writeSection(TypeVuln, w.buffer.VulnResults)
+
+	// 单独输出 Web 服务列表（便于复制测试）
+	w.writeWebServices()
+
+	w.closed = true
+
+	// 关闭并删除实时备份文件（正常结束，不再需要）
+	if w.realtimeFile != nil {
+		w.realtimeFile.Close()
+		os.Remove(w.realtimePath)
+	}
+
+	if err := w.bufWriter.Flush(); err != nil {
+		return err
+	}
+	if err := w.file.Sync(); err != nil {
+		return err
+	}
+	return w.file.Close()
+}
+
+// writeSection 写入一个分类的所有结果
+func (w *TXTWriter) writeSection(resultType ResultType, results []*ScanResult) {
+	if len(results) == 0 {
+		return
+	}
+
+	separator := w.getSeparator(resultType)
+	_, _ = w.bufWriter.WriteString(separator + "\n")
+
+	for _, result := range results {
+		line := w.formatLine(result)
+		if line != "" {
+			_, _ = w.bufWriter.WriteString(line + "\n")
+		}
+	}
+	_, _ = w.bufWriter.WriteString("\n")
+}
+
+// writeWebServices 单独输出 Web 服务 URL 列表
+func (w *TXTWriter) writeWebServices() {
+	var urls []string
+
+	for _, result := range w.buffer.ServiceResults {
+		if !w.isWebService(result) {
+			continue
+		}
+
+		target := result.Target
+		if !strings.Contains(target, ":") {
+			if port := w.getDetail(result, "port"); port != nil {
+				target = fmt.Sprintf("%s:%v", target, port)
+			}
+		}
+
+		protocol := "http"
+		service := w.getDetailStr(result, "service")
+		if service == "https" || strings.Contains(target, ":443") {
+			protocol = "https"
+		}
+
+		urls = append(urls, fmt.Sprintf("%s://%s", protocol, target))
+	}
+
+	if len(urls) == 0 {
+		return
+	}
+
+	_, _ = w.bufWriter.WriteString("# ===== Web服务 =====\n")
+	for _, url := range urls {
+		_, _ = w.bufWriter.WriteString(url + "\n")
+	}
+	_, _ = w.bufWriter.WriteString("\n")
+}
+
+// isWebService 判断是否为 Web 服务
+func (w *TXTWriter) isWebService(result *ScanResult) bool {
+	if v, ok := w.getDetail(result, "is_web").(bool); ok && v {
+		return true
+	}
+	if w.getDetail(result, "status") != nil {
+		return true
+	}
+	if w.getDetailStr(result, "server") != "" {
+		return true
+	}
+	service := w.getDetailStr(result, "service")
+	return service == "http" || service == "https"
+}
+
+// GetFormat 获取格式类型
+func (w *TXTWriter) GetFormat() Format {
+	return FormatTXT
+}
+
+// =============================================================================
+// JSONWriter - JSON格式写入器
+// =============================================================================
+
+// JSONWriter JSON格式写入器（分类去重，输出完整JSON）
+// 双写机制：内存分类缓冲 + 实时NDJSON备份
+type JSONWriter struct {
+	file         *os.File
+	mu           sync.Mutex
+	closed       bool
+	buffer       *ResultBuffer
+	realtimeFile *os.File // 实时备份文件（NDJSON格式）
+	realtimePath string   // 实时备份文件路径
+}
+
+// JSONOutput JSON输出结构
+type JSONOutput struct {
+	ScanTime time.Time     `json:"scan_time"`
+	Summary  JSONSummary   `json:"summary"`
+	Hosts    []*ScanResult `json:"hosts,omitempty"`
+	Ports    []*ScanResult `json:"ports,omitempty"`
+	Services []*ScanResult `json:"services,omitempty"`
+	Vulns    []*ScanResult `json:"vulns,omitempty"`
+}
+
+// JSONSummary 扫描摘要
+type JSONSummary struct {
+	TotalHosts    int `json:"total_hosts"`
+	TotalPorts    int `json:"total_ports"`
+	TotalServices int `json:"total_services"`
+	TotalVulns    int `json:"total_vulns"`
+}
+
+// NewJSONWriter 创建JSON写入器
+func NewJSONWriter(filePath string) (*JSONWriter, error) {
+	file, err := os.OpenFile(filePath, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, DefaultFilePermissions)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create JSON file: %w", err)
+	}
+
+	// 创建实时备份文件（NDJSON格式，每行一个JSON对象）
+	realtimePath := filePath + ".realtime.tmp"
+	realtimeFile, err := os.OpenFile(realtimePath, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, DefaultFilePermissions)
+	if err != nil {
+		file.Close()
+		return nil, fmt.Errorf("failed to create realtime backup file: %w", err)
+	}
+
+	return &JSONWriter{
+		file:         file,
+		buffer:       NewResultBuffer(),
+		realtimeFile: realtimeFile,
+		realtimePath: realtimePath,
+	}, nil
+}
+
+// WriteHeader 写入头部
+func (w *JSONWriter) WriteHeader() error {
+	return nil
+}
+
+// Write 收集扫描结果，同时实时写入备份文件
+func (w *JSONWriter) Write(result *ScanResult) error {
+	w.mu.Lock()
+	defer w.mu.Unlock()
+
+	if w.closed {
+		return fmt.Errorf("writer is closed")
+	}
+	if result == nil {
+		return fmt.Errorf("result cannot be nil")
+	}
+
+	// 1. 加入内存分类缓冲（用于最终有序输出）
+	w.buffer.Add(result)
+
+	// 2. 实时写入备份文件（NDJSON格式，防崩溃丢失）
+	if w.realtimeFile != nil {
+		data, err := json.Marshal(result)
+		if err != nil {
+			return fmt.Errorf("failed to marshal result: %w", err)
+		}
+		if _, err := w.realtimeFile.Write(append(data, '\n')); err != nil {
+			return fmt.Errorf("failed to write realtime backup: %w", err)
+		}
+		if err := w.realtimeFile.Sync(); err != nil {
+			return fmt.Errorf("failed to sync realtime backup: %w", err)
+		}
+	}
+
+	return nil
+}
+
+// Flush 刷新写入器
+func (w *JSONWriter) Flush() error {
+	return nil
+}
+
+// Close 关闭写入器（写入完整JSON，删除临时备份）
+func (w *JSONWriter) Close() error {
+	w.mu.Lock()
+	defer w.mu.Unlock()
+
+	if w.closed {
+		return nil
+	}
+
+	hosts, ports, services, vulns := w.buffer.Summary()
+	output := JSONOutput{
+		ScanTime: time.Now(),
+		Summary: JSONSummary{
+			TotalHosts:    hosts,
+			TotalPorts:    ports,
+			TotalServices: services,
+			TotalVulns:    vulns,
+		},
+		Hosts:    w.buffer.HostResults,
+		Ports:    w.buffer.PortResults,
+		Services: w.buffer.ServiceResults,
+		Vulns:    w.buffer.VulnResults,
+	}
+
+	data, err := json.MarshalIndent(output, JSONIndentPrefix, JSONIndentString)
+	if err != nil {
+		return err
+	}
+
+	w.closed = true
+
+	// 关闭并删除实时备份文件（正常结束，不再需要）
+	if w.realtimeFile != nil {
+		w.realtimeFile.Close()
+		os.Remove(w.realtimePath)
+	}
+
+	if _, err := w.file.Write(data); err != nil {
+		return err
+	}
+	return w.file.Close()
+}
+
+// GetFormat 获取格式类型
+func (w *JSONWriter) GetFormat() Format {
+	return FormatJSON
+}
+
+// =============================================================================
+// CSVWriter - CSV格式写入器
+// =============================================================================
+
+// CSVWriter CSV格式写入器（分类去重）
+// 双写机制：内存分类缓冲 + 实时NDJSON备份
+type CSVWriter struct {
+	file         *os.File
+	bufWriter    *bufio.Writer
+	csvWriter    *csv.Writer
+	mu           sync.Mutex
+	closed       bool
+	buffer       *ResultBuffer
+	realtimeFile *os.File // 实时备份文件（NDJSON格式）
+	realtimePath string   // 实时备份文件路径
+}
+
+// NewCSVWriter 创建CSV写入器
+func NewCSVWriter(filePath string) (*CSVWriter, error) {
+	file, err := os.OpenFile(filePath, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, DefaultFilePermissions)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create CSV file: %w", err)
+	}
+
+	// 创建实时备份文件（NDJSON格式）
+	realtimePath := filePath + ".realtime.tmp"
+	realtimeFile, err := os.OpenFile(realtimePath, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, DefaultFilePermissions)
+	if err != nil {
+		file.Close()
+		return nil, fmt.Errorf("failed to create realtime backup file: %w", err)
+	}
+
+	bufWriter := bufio.NewWriter(file)
+	csvWriter := csv.NewWriter(bufWriter)
+
+	return &CSVWriter{
+		file:         file,
+		bufWriter:    bufWriter,
+		csvWriter:    csvWriter,
+		buffer:       NewResultBuffer(),
+		realtimeFile: realtimeFile,
+		realtimePath: realtimePath,
+	}, nil
+}
+
+// WriteHeader 写入CSV头部
+func (w *CSVWriter) WriteHeader() error {
+	return nil // 延迟到Close时写入
+}
+
+// Write 收集扫描结果，同时实时写入备份文件
+func (w *CSVWriter) Write(result *ScanResult) error {
+	w.mu.Lock()
+	defer w.mu.Unlock()
+
+	if w.closed {
+		return fmt.Errorf("writer is closed")
+	}
+	if result == nil {
+		return fmt.Errorf("result cannot be nil")
+	}
+
+	// 1. 加入内存分类缓冲（用于最终有序输出）
+	w.buffer.Add(result)
+
+	// 2. 实时写入备份文件（NDJSON格式，防崩溃丢失）
+	if w.realtimeFile != nil {
+		data, err := json.Marshal(result)
+		if err != nil {
+			return fmt.Errorf("failed to marshal result: %w", err)
+		}
+		if _, err := w.realtimeFile.Write(append(data, '\n')); err != nil {
+			return fmt.Errorf("failed to write realtime backup: %w", err)
+		}
+		if err := w.realtimeFile.Sync(); err != nil {
+			return fmt.Errorf("failed to sync realtime backup: %w", err)
+		}
+	}
+
+	return nil
+}
+
+// Flush 刷新写入器
+func (w *CSVWriter) Flush() error {
+	return nil
+}
+
+// Close 关闭写入器（按类型分组写入，删除临时备份）
+func (w *CSVWriter) Close() error {
+	w.mu.Lock()
+	defer w.mu.Unlock()
+
+	if w.closed {
+		return nil
+	}
+
+	// 写入各分类
+	w.writeSection("# Hosts", []string{"Target"}, w.buffer.HostResults, w.formatHostRecord)
+	w.writeSection("# Ports", []string{"Target", "Port", "Status"}, w.buffer.PortResults, w.formatPortRecord)
+	w.writeSection("# Services", []string{"Target", "Service", "Version", "Banner"}, w.buffer.ServiceResults, w.formatServiceRecord)
+	w.writeSection("# Vulns", []string{"Target", "Type", "Details"}, w.buffer.VulnResults, w.formatVulnRecord)
+
+	w.closed = true
+
+	// 关闭并删除实时备份文件（正常结束，不再需要）
+	if w.realtimeFile != nil {
+		w.realtimeFile.Close()
+		os.Remove(w.realtimePath)
+	}
+
+	w.csvWriter.Flush()
+	if err := w.csvWriter.Error(); err != nil {
+		return err
+	}
+	if err := w.bufWriter.Flush(); err != nil {
+		return err
+	}
+	return w.file.Close()
+}
+
+func (w *CSVWriter) writeSection(title string, headers []string, results []*ScanResult, formatter func(*ScanResult) []string) {
+	if len(results) == 0 {
+		return
+	}
+
+	_ = w.csvWriter.Write([]string{title})
+	_ = w.csvWriter.Write(headers)
+
+	for _, result := range results {
+		_ = w.csvWriter.Write(formatter(result))
+	}
+	_ = w.csvWriter.Write([]string{})
+}
+
+func (w *CSVWriter) formatHostRecord(result *ScanResult) []string {
+	return []string{result.Target}
+}
+
+func (w *CSVWriter) formatPortRecord(result *ScanResult) []string {
+	port := ""
+	if result.Details != nil {
+		if p, ok := result.Details["port"]; ok {
+			port = fmt.Sprintf("%v", p)
+		}
+	}
+	return []string{result.Target, port, "open"}
+}
+
+func (w *CSVWriter) formatServiceRecord(result *ScanResult) []string {
+	service, version, banner := "", "", ""
+	if result.Details != nil {
+		if s, ok := result.Details["service"].(string); ok {
+			service = s
+		}
+		if s, ok := result.Details["name"].(string); ok && service == "" {
+			service = s
+		}
+		if v, ok := result.Details["version"].(string); ok {
+			version = v
+		}
+		if b, ok := result.Details["banner"].(string); ok {
+			banner = escapeControlChars(b)
+			if len(banner) > 100 {
+				banner = banner[:100] + "..."
+			}
+		}
+	}
+	target := result.Target
+	if !strings.Contains(target, ":") {
+		if p, ok := result.Details["port"]; ok {
+			target = fmt.Sprintf("%s:%v", target, p)
+		}
+	}
+	return []string{target, service, version, banner}
+}
+
+func (w *CSVWriter) formatVulnRecord(result *ScanResult) []string {
+	vulnType := ""
+	if result.Details != nil {
+		if t, ok := result.Details["type"].(string); ok {
+			vulnType = t
+		}
+	}
+	return []string{result.Target, vulnType, result.Status}
+}
+
+// GetFormat 获取格式类型
+func (w *CSVWriter) GetFormat() Format {
+	return FormatCSV
+}