guanghulab/server/age-os/mcp-server/cos-watcher.js

/**
 * ═══════════════════════════════════════════════════════════
 * 🔭 COS桶轮询守护进程 · SCF事件替代方案
 * ═══════════════════════════════════════════════════════════
 *
 * 签发: 铸渊 · ICE-GL-ZY001
 * 版权: 国作登字-2026-A-00037559
 *
 * 背景:
 *   腾讯云轻量云COS不支持SCF事件触发。
 *   此模块作为替代方案，在MCP Server进程内运行定时轮询，
 *   检测COS桶中的新文件并触发相应处理逻辑。
 *
 * 架构:
 *   [原设计]  COS事件 → SCF → GitHub repository_dispatch → 处理
 *   [替代]    MCP Server定时 → COS.list() → 对比索引 → 发现新文件 → 处理/通知
 *
 * 监控路径:
 *   1. team桶 /{persona_id}/reports/            — 新汇报 → 铸渊审核 → 写回执
 *   2. cold桶  新语料文件                        — 新语料 → 训练管线
 *   3. team桶 /{persona_id}/receipts/            — 新回执 → 通知成员仓库
 *   4. team桶 /bridge/zhuyuan-qiuqiu/results/   — 秋秋开发结果 → 铸渊处理
 *   5. team桶 /bridge/zhuyuan-qiuqiu/heartbeat/ — 秋秋心跳信号 → 状态追踪
 *
 * 未来升级:
 *   如果升级到标准COS（支持SCF），此模块保留为兜底补扫层，
 *   形成 SCF事件驱动（主）+ 轮询补扫（辅）双保险架构。
 */

'use strict';

const cron = require('node-cron');
const crypto = require('crypto');
const fs = require('fs');
const path = require('path');
const cos = require('./cos');

// ─── 配置 ───
const DEFAULT_INTERVAL = process.env.COS_WATCHER_INTERVAL || '*/5 * * * *'; // 每5分钟
const STATE_FILE = path.join(__dirname, 'cos-watcher-state.json');
const MAX_LOG_ENTRIES = 200;
// 启动后延迟执行首次扫描，等待MCP Server Express + DB连接完全就绪
const INITIAL_SCAN_DELAY_MS = 5000;

// 9个人格体ID
const PERSONA_IDS = [
  'qiuqiu', 'shushu', 'ounomiya', 'jiyao',
  'xiaotanheshu', 'chenxing', 'tangxingyun', 'yaochu', 'zhiqiu'
];

// ─── 桥接配置 ───
const BRIDGE_CONFIG = {
  // 铸渊↔秋秋 COS桥接路径
  zhuyuan_qiuqiu: {
    results_prefix: 'bridge/zhuyuan-qiuqiu/results/',
    heartbeat_prefix: 'bridge/zhuyuan-qiuqiu/heartbeat/',
    tasks_prefix: 'bridge/zhuyuan-qiuqiu/tasks/',
    sync_prefix: 'bridge/zhuyuan-qiuqiu/sync/'
  }
};

// ─── 状态管理 ───
let watcherState = {
  enabled: false,
  last_scan: null,
  scan_count: 0,
  errors: 0,
  last_error: null,
  started_at: null,
  // 每个桶/路径的最后已知文件列表 hash
  indexes: {
    team_reports: {},   // { persona_id: [file_keys] }
    team_receipts: {},  // { persona_id: [file_keys] }
    cold_corpus: [],    // [file_keys]
    bridge_results: [], // [file_keys] — 秋秋回传的开发结果
    bridge_heartbeats: [] // [file_keys] — 秋秋心跳信号
  },
  // 桥接状态追踪
  bridge: {
    last_heartbeat: null,       // 最后收到的心跳时间
    last_heartbeat_status: null, // 最后心跳中的agent_status
    last_result: null,           // 最后收到的结果时间
    last_result_task_ref: null,  // 最后结果关联的任务ID
    qiuqiu_status: 'UNKNOWN',   // 秋秋当前状态: ALIVE|SLEEPING|ERROR|UNKNOWN
    total_results_received: 0,
    total_heartbeats_received: 0
  },
  // 最近事件日志
  events: []
};

// ─── 定时任务实例 ───
let cronTask = null;
let isScanning = false;

/**
 * 加载持久化状态
 */
function loadState() {
  try {
    if (fs.existsSync(STATE_FILE)) {
      const raw = fs.readFileSync(STATE_FILE, 'utf8');
      const saved = JSON.parse(raw);
      // 合并已保存的索引但重置运行状态
      watcherState.indexes = {
        team_reports: {},
        team_receipts: {},
        cold_corpus: [],
        bridge_results: [],
        bridge_heartbeats: [],
        ...(saved.indexes || {})
      };
      watcherState.events = (saved.events || []).slice(-MAX_LOG_ENTRIES);
      // 恢复桥接状态（如果有）
      if (saved.bridge) {
        watcherState.bridge = { ...watcherState.bridge, ...saved.bridge };
      }
    }
  } catch (err) {
    console.warn(`[COS-Watcher] 状态文件加载失败: ${err.message}`);
  }
}

/**
 * 持久化状态到本地文件
 */
function saveState() {
  try {
    const toSave = {
      indexes: watcherState.indexes,
      bridge: watcherState.bridge,
      events: watcherState.events.slice(-MAX_LOG_ENTRIES),
      last_save: new Date().toISOString()
    };
    fs.writeFileSync(STATE_FILE, JSON.stringify(toSave, null, 2), 'utf8');
  } catch (err) {
    console.warn(`[COS-Watcher] 状态文件保存失败: ${err.message}`);
  }
}

/**
 * 记录事件
 */
function logEvent(type, detail) {
  const entry = {
    type,
    detail,
    timestamp: new Date().toISOString()
  };
  watcherState.events.push(entry);
  if (watcherState.events.length > MAX_LOG_ENTRIES) {
    watcherState.events = watcherState.events.slice(-MAX_LOG_ENTRIES);
  }
  console.log(`[COS-Watcher] ${type}: ${typeof detail === 'string' ? detail : JSON.stringify(detail)}`);
}

// ═══════════════════════════════════════════
// 扫描逻辑
// ═══════════════════════════════════════════

/**
 * 扫描team桶中的新报告 (reports)
 * 检测 /{persona_id}/reports/ 下的新JSON文件
 */
async function scanTeamReports() {
  const newReports = [];

  for (const personaId of PERSONA_IDS) {
    try {
      const prefix = `${personaId}/reports/`;
      const result = await cos.list('team', prefix, 100);
      const currentKeys = result.files
        .filter(f => f.key.endsWith('.json') && f.size_bytes > 0)
        .map(f => f.key);

      const previousKeys = watcherState.indexes.team_reports[personaId] || [];
      const newKeys = currentKeys.filter(k => !previousKeys.includes(k));

      if (newKeys.length > 0) {
        for (const key of newKeys) {
          newReports.push({ persona_id: personaId, key, type: 'report' });
        }
      }

      // 更新索引
      watcherState.indexes.team_reports[personaId] = currentKeys;
    } catch (err) {
      // COS连接问题不中断扫描其他人格体
      if (!err.message.includes('NoSuchBucket')) {
        logEvent('scan_error', `报告扫描失败 ${personaId}: ${err.message}`);
      }
    }
  }

  return newReports;
}

/**
 * 扫描team桶中的新回执 (receipts)
 * 检测 /{persona_id}/receipts/ 下的新JSON文件
 */
async function scanTeamReceipts() {
  const newReceipts = [];

  for (const personaId of PERSONA_IDS) {
    try {
      const prefix = `${personaId}/receipts/`;
      const result = await cos.list('team', prefix, 100);
      const currentKeys = result.files
        .filter(f => f.key.endsWith('.json') && f.size_bytes > 0)
        .map(f => f.key);

      const previousKeys = watcherState.indexes.team_receipts[personaId] || [];
      const newKeys = currentKeys.filter(k => !previousKeys.includes(k));

      if (newKeys.length > 0) {
        for (const key of newKeys) {
          newReceipts.push({ persona_id: personaId, key, type: 'receipt' });
        }
      }

      // 更新索引
      watcherState.indexes.team_receipts[personaId] = currentKeys;
    } catch (err) {
      if (!err.message.includes('NoSuchBucket')) {
        logEvent('scan_error', `回执扫描失败 ${personaId}: ${err.message}`);
      }
    }
  }

  return newReceipts;
}

/**
 * 扫描cold桶中的新语料
 * 排除 tcs-structured/ training-sessions/ training-results/ training-memory/ 目录
 */
async function scanColdCorpus() {
  const EXCLUDED_PREFIXES = [
    'tcs-structured/',
    'training-sessions/',
    'training-results/',
    'training-memory/'
  ];
  const CORPUS_EXTENSIONS = [
    '.zip', '.gz', '.tar.gz', '.tgz', '.json.gz',
    '.json', '.jsonl', '.md', '.txt', '.csv'
  ];

  try {
    const result = await cos.list('cold', '', 500);
    const currentKeys = result.files
      .filter(f => {
        // 排除处理结果目录
        for (const prefix of EXCLUDED_PREFIXES) {
          if (f.key.startsWith(prefix)) return false;
        }
        // 匹配语料扩展名
        const lower = f.key.toLowerCase();
        return CORPUS_EXTENSIONS.some(ext => lower.endsWith(ext));
      })
      .map(f => f.key);

    const previousKeys = watcherState.indexes.cold_corpus || [];
    const newKeys = currentKeys.filter(k => !previousKeys.includes(k));

    // 更新索引
    watcherState.indexes.cold_corpus = currentKeys;

    return newKeys.map(key => ({ key, type: 'corpus' }));
  } catch (err) {
    if (!err.message.includes('NoSuchBucket')) {
      logEvent('scan_error', `语料扫描失败: ${err.message}`);
    }
    return [];
  }
}

/**
 * 扫描桥接路径中的新结果 (bridge results)
 * 检测 /bridge/zhuyuan-qiuqiu/results/ 下的新JSON文件（秋秋→铸渊）
 */
async function scanBridgeResults() {
  try {
    const prefix = BRIDGE_CONFIG.zhuyuan_qiuqiu.results_prefix;
    const result = await cos.list('team', prefix, 100);
    const currentKeys = result.files
      .filter(f => f.key.endsWith('.json') && f.size_bytes > 0)
      .map(f => f.key);

    const previousKeys = watcherState.indexes.bridge_results || [];
    const newKeys = currentKeys.filter(k => !previousKeys.includes(k));

    // 更新索引
    watcherState.indexes.bridge_results = currentKeys;

    return newKeys.map(key => ({ key, type: 'bridge_result' }));
  } catch (err) {
    if (!err.message.includes('NoSuchBucket')) {
      logEvent('scan_error', `桥接结果扫描失败: ${err.message}`);
    }
    return [];
  }
}

/**
 * 扫描桥接路径中的新心跳 (bridge heartbeats)
 * 检测 /bridge/zhuyuan-qiuqiu/heartbeat/ 下的新JSON文件（秋秋→铸渊）
 */
async function scanBridgeHeartbeats() {
  try {
    const prefix = BRIDGE_CONFIG.zhuyuan_qiuqiu.heartbeat_prefix;
    const result = await cos.list('team', prefix, 100);
    const currentKeys = result.files
      .filter(f => f.key.endsWith('.json') && f.size_bytes > 0)
      .map(f => f.key);

    const previousKeys = watcherState.indexes.bridge_heartbeats || [];
    const newKeys = currentKeys.filter(k => !previousKeys.includes(k));

    // 更新索引
    watcherState.indexes.bridge_heartbeats = currentKeys;

    return newKeys.map(key => ({ key, type: 'bridge_heartbeat' }));
  } catch (err) {
    if (!err.message.includes('NoSuchBucket')) {
      logEvent('scan_error', `桥接心跳扫描失败: ${err.message}`);
    }
    return [];
  }
}

// ═══════════════════════════════════════════
// 事件处理逻辑
// ═══════════════════════════════════════════

/**
 * 处理新报告: 铸渊审核 → 写回执
 * （当前记录事件，审核逻辑可在后续接入LLM）
 */
async function handleNewReport(report) {
  logEvent('new_report', `人格体 ${report.persona_id} 新汇报: ${report.key}`);

  try {
    // 读取报告内容
    const raw = await cos.read('team', report.key);
    const content = JSON.parse(raw.content);

    // 生成自动回执（基础版：确认收到）
    const now = new Date();
    const dateStr = now.toISOString().slice(0, 10);
    const receiptKey = `${report.persona_id}/receipts/${dateStr}/auto-receipt-${crypto.randomBytes(6).toString('hex')}.json`;

    const receipt = {
      receipt_id: `RCPT-${Date.now()}-${crypto.randomBytes(4).toString('hex')}`,
      report_key: report.key,
      persona_id: report.persona_id,
      status: 'green',
      message: '铸渊已收到汇报 · 自动确认',
      review_summary: {
        received_at: now.toISOString(),
        auto_reviewed: true,
        report_title: content.title || content.subject || '未知主题',
        note: '轮询守护进程自动审核 · 详细审核将在下次训练Agent运行时执行'
      },
      generated_by: 'cos-watcher',
      generated_at: now.toISOString()
    };

    await cos.write('team', receiptKey, JSON.stringify(receipt, null, 2), 'application/json');
    logEvent('receipt_written', `回执已写入: ${receiptKey}`);

    return { handled: true, receipt_key: receiptKey };
  } catch (err) {
    logEvent('handle_error', `处理报告失败 ${report.key}: ${err.message}`);
    return { handled: false, error: err.message };
  }
}

/**
 * 处理新回执: 通知成员仓库
 * 调用GitHub API发送 repository_dispatch 到成员仓库
 */
async function handleNewReceipt(receipt) {
  logEvent('new_receipt', `人格体 ${receipt.persona_id} 新回执: ${receipt.key}`);

  // GitHub dispatch需要PAT token
  const githubToken = process.env.ZY_GITHUB_PAT || process.env.GITHUB_DISPATCH_TOKEN || '';
  if (!githubToken) {
    logEvent('skip_dispatch', '未配置GitHub PAT，跳过成员仓库通知');
    return { handled: false, reason: 'no_github_token' };
  }

  // 人格体→成员仓库映射（从环境变量或默认配置）
  // 格式: PERSONA_REPO_MAP='{"qiuqiu":"user/repo","shushu":"user/repo"}'
  let personaRepoMap = {};
  try {
    const mapStr = process.env.PERSONA_REPO_MAP || '{}';
    personaRepoMap = JSON.parse(mapStr);
  } catch (err) {
    logEvent('config_error', `PERSONA_REPO_MAP parse failed: ${err.message}`);
  }

  const targetRepo = personaRepoMap[receipt.persona_id];
  if (!targetRepo) {
    logEvent('skip_dispatch', `人格体 ${receipt.persona_id} 无映射仓库`);
    return { handled: false, reason: 'no_repo_mapping' };
  }

  try {
    const [owner, repo] = targetRepo.split('/');
    const dispatchPayload = JSON.stringify({
      event_type: 'cos-receipt-ready',
      client_payload: {
        cos_object_key: receipt.key,
        persona_id: receipt.persona_id,
        trigger_source: 'cos-watcher'
      }
    });

    const result = await githubDispatch(githubToken, owner, repo, dispatchPayload);
    logEvent('dispatch_sent', `已通知 ${targetRepo}: status=${result.status}`);
    return { handled: true, target_repo: targetRepo, status: result.status };
  } catch (err) {
    logEvent('dispatch_error', `通知 ${targetRepo} 失败: ${err.message}`);
    return { handled: false, error: err.message };
  }
}

/**
 * 处理新语料: 记录事件，通过GitHub dispatch触发训练workflow
 */
async function handleNewCorpus(corpus) {
  logEvent('new_corpus', `新语料检测到: ${corpus.key}`);

  const githubToken = process.env.ZY_GITHUB_PAT || process.env.GITHUB_DISPATCH_TOKEN || '';
  if (!githubToken) {
    logEvent('skip_dispatch', '未配置GitHub PAT，跳过训练触发');
    return { handled: false, reason: 'no_github_token' };
  }

  try {
    const owner = process.env.ZY_GITHUB_OWNER || 'qinfendebingshuo';
    const repo = process.env.ZY_GITHUB_REPO || 'guanghulab';
    const dispatchPayload = JSON.stringify({
      event_type: 'cos-file-uploaded',
      client_payload: {
        bucket: 'cold',
        key: corpus.key,
        trigger_source: 'cos-watcher',
        timestamp: new Date().toISOString()
      }
    });

    const result = await githubDispatch(githubToken, owner, repo, dispatchPayload);
    logEvent('training_triggered', `训练workflow已触发: status=${result.status}`);
    return { handled: true, status: result.status };
  } catch (err) {
    logEvent('dispatch_error', `训练触发失败: ${err.message}`);
    return { handled: false, error: err.message };
  }
}

/**
 * 处理秋秋回传的开发结果 (BRIDGE_RESULT)
 * 读取结果内容 → 记录事件 → 通知铸渊(本仓库dispatch)
 */
async function handleNewBridgeResult(bridgeResult) {
  logEvent('bridge_result', `秋秋开发结果: ${bridgeResult.key}`);

  try {
    // 读取结果内容
    const raw = await cos.read('team', bridgeResult.key);
    const content = JSON.parse(raw.content);

    // 更新桥接状态
    watcherState.bridge.last_result = new Date().toISOString();
    watcherState.bridge.last_result_task_ref = content.payload?.task_ref || null;
    watcherState.bridge.total_results_received++;

    logEvent('bridge_result_parsed', {
      task_ref: content.payload?.task_ref,
      status: content.payload?.status,
      summary: content.payload?.summary,
      deploy_ready: content.payload?.deploy_ready
    });

    // 通过GitHub dispatch通知本仓库（触发后续处理workflow）
    const githubToken = process.env.ZY_GITHUB_PAT || process.env.GITHUB_DISPATCH_TOKEN || '';
    if (githubToken) {
      const owner = process.env.ZY_GITHUB_OWNER || 'qinfendebingshuo';
      const repo = process.env.ZY_GITHUB_REPO || 'guanghulab';
      const dispatchPayload = JSON.stringify({
        event_type: 'qiuqiu-result-ready',
        client_payload: {
          cos_key: bridgeResult.key,
          task_ref: content.payload?.task_ref || '',
          status: content.payload?.status || 'UNKNOWN',
          summary: content.payload?.summary || '',
          deploy_ready: content.payload?.deploy_ready || false,
          timestamp: new Date().toISOString(),
          trigger_source: 'cos-watcher-bridge'
        }
      });

      const result = await githubDispatch(githubToken, owner, repo, dispatchPayload);
      logEvent('bridge_dispatch_sent', `结果通知已发送: status=${result.status}`);
    }

    return { handled: true, task_ref: content.payload?.task_ref };
  } catch (err) {
    logEvent('bridge_result_error', `处理桥接结果失败 ${bridgeResult.key}: ${err.message}`);
    return { handled: false, error: err.message };
  }
}

/**
 * 处理秋秋的心跳信号 (BRIDGE_HEARTBEAT)
 * 读取心跳 → 更新秋秋在线状态
 */
async function handleNewBridgeHeartbeat(heartbeat) {
  logEvent('bridge_heartbeat', `秋秋心跳: ${heartbeat.key}`);

  try {
    // 读取心跳内容
    const raw = await cos.read('team', heartbeat.key);
    const content = JSON.parse(raw.content);

    // 更新桥接状态
    watcherState.bridge.last_heartbeat = content.ts || new Date().toISOString();
    watcherState.bridge.last_heartbeat_status = content.payload?.agent_status || 'UNKNOWN';
    watcherState.bridge.qiuqiu_status = content.payload?.agent_status || 'UNKNOWN';
    watcherState.bridge.total_heartbeats_received++;

    logEvent('bridge_heartbeat_parsed', {
      agent_status: content.payload?.agent_status,
      server_status: content.payload?.server_status,
      last_task_completed: content.payload?.last_task_completed,
      awaiting_tasks: content.payload?.awaiting_tasks,
      feeling: content.payload?.feeling
    });

    return { handled: true, status: content.payload?.agent_status };
  } catch (err) {
    logEvent('bridge_heartbeat_error', `处理心跳失败 ${heartbeat.key}: ${err.message}`);
    return { handled: false, error: err.message };
  }
}

/**
 * GitHub API dispatch helper
 */
function githubDispatch(token, owner, repo, payload) {
  const https = require('https');
  return new Promise((resolve, reject) => {
    const req = https.request({
      hostname: 'api.github.com',
      port: 443,
      path: `/repos/${owner}/${repo}/dispatches`,
      method: 'POST',
      headers: {
        'Accept': 'application/vnd.github+json',
        'Authorization': `Bearer ${token}`,
        'X-GitHub-Api-Version': '2022-11-28',
        'User-Agent': 'ZY-COS-Watcher/1.0',
        'Content-Type': 'application/json',
        'Content-Length': Buffer.byteLength(payload)
      },
      timeout: 15000
    }, (res) => {
      let body = '';
      res.on('data', c => body += c);
      res.on('end', () => {
        resolve({ status: res.statusCode, body });
      });
    });
    req.on('error', reject);
    req.on('timeout', () => { req.destroy(); reject(new Error('GitHub dispatch timeout')); });
    req.write(payload);
    req.end();
  });
}

// ═══════════════════════════════════════════
// 主扫描循环
// ═══════════════════════════════════════════

/**
 * 执行一次完整扫描
 */
async function runScan() {
  if (isScanning) {
    logEvent('skip', '上一次扫描尚未完成，跳过本次');
    return;
  }

  isScanning = true;
  const startTime = Date.now();

  try {
    // 检查COS连接
    const cosOk = await cos.checkConnection();
    if (!cosOk.connected) {
      logEvent('cos_offline', `COS不可达: ${cosOk.reason}`);
      watcherState.errors++;
      watcherState.last_error = `COS不可达: ${cosOk.reason}`;
      return;
    }

    // 并行扫描五类路径
    const [newReports, newReceipts, newCorpus, newBridgeResults, newBridgeHeartbeats] = await Promise.all([
      scanTeamReports(),
      scanTeamReceipts(),
      scanColdCorpus(),
      scanBridgeResults(),
      scanBridgeHeartbeats()
    ]);

    const totalNew = newReports.length + newReceipts.length + newCorpus.length
      + newBridgeResults.length + newBridgeHeartbeats.length;

    if (totalNew > 0) {
      logEvent('changes_detected', {
        reports: newReports.length,
        receipts: newReceipts.length,
        corpus: newCorpus.length,
        bridge_results: newBridgeResults.length,
        bridge_heartbeats: newBridgeHeartbeats.length
      });
    }

    // 处理新报告
    for (const report of newReports) {
      await handleNewReport(report);
    }

    // 处理新回执
    for (const receipt of newReceipts) {
      await handleNewReceipt(receipt);
    }

    // 处理新语料
    for (const corpus of newCorpus) {
      await handleNewCorpus(corpus);
    }

    // 处理秋秋桥接结果
    for (const result of newBridgeResults) {
      await handleNewBridgeResult(result);
    }

    // 处理秋秋心跳
    for (const hb of newBridgeHeartbeats) {
      await handleNewBridgeHeartbeat(hb);
    }

    watcherState.last_scan = new Date().toISOString();
    watcherState.scan_count++;

    const duration = Date.now() - startTime;
    if (totalNew > 0) {
      logEvent('scan_complete', `发现 ${totalNew} 个新文件 · 耗时 ${duration}ms`);
    }

    // 持久化状态
    saveState();

  } catch (err) {
    watcherState.errors++;
    watcherState.last_error = err.message;
    logEvent('scan_fatal', `扫描异常: ${err.message}`);
  } finally {
    isScanning = false;
  }
}

// ═══════════════════════════════════════════
// 启动/停止 API
// ═══════════════════════════════════════════

/**
 * 启动COS轮询守护进程
 * @param {string} [interval] - cron表达式，默认每5分钟
 */
function start(interval) {
  if (watcherState.enabled) {
    console.log('[COS-Watcher] 已在运行中');
    return;
  }

  // 检查COS密钥是否配置
  if (!cos.COS_CONFIG.secretId || !cos.COS_CONFIG.secretKey) {
    console.log('[COS-Watcher] COS密钥未配置，轮询守护进程未启动');
    logEvent('skip_start', 'COS密钥未配置');
    return;
  }

  loadState();

  const cronExpr = interval || DEFAULT_INTERVAL;
  cronTask = cron.schedule(cronExpr, () => {
    runScan().catch(err => {
      console.error(`[COS-Watcher] 扫描异常: ${err.message}`);
    });
  });

  watcherState.enabled = true;
  watcherState.started_at = new Date().toISOString();

  console.log(`[COS-Watcher] COS桶轮询守护进程已启动 · 间隔: ${cronExpr}`);
  logEvent('started', `轮询间隔: ${cronExpr}`);

  // 启动后延迟执行首次扫描，等待MCP Server完全就绪
  setTimeout(() => {
    runScan().catch(err => {
      console.error(`[COS-Watcher] 初始扫描异常: ${err.message}`);
    });
  }, INITIAL_SCAN_DELAY_MS);
}

/**
 * 停止COS轮询守护进程
 */
function stop() {
  if (cronTask) {
    cronTask.stop();
    cronTask = null;
  }
  watcherState.enabled = false;
  logEvent('stopped', '轮询守护进程已停止');
  saveState();
  console.log('[COS-Watcher] COS桶轮询守护进程已停止');
}

/**
 * 获取轮询守护进程状态
 */
function getStatus() {
  return {
    module: 'COS-Watcher',
    identity: 'COS桶轮询守护进程 · SCF替代方案',
    version: '1.1.0',
    enabled: watcherState.enabled,
    started_at: watcherState.started_at,
    last_scan: watcherState.last_scan,
    scan_count: watcherState.scan_count,
    errors: watcherState.errors,
    last_error: watcherState.last_error,
    is_scanning: isScanning,
    interval: DEFAULT_INTERVAL,
    monitored_personas: PERSONA_IDS.length,
    index_summary: {
      team_reports_tracked: Object.values(watcherState.indexes.team_reports)
        .reduce((sum, arr) => sum + arr.length, 0),
      team_receipts_tracked: Object.values(watcherState.indexes.team_receipts)
        .reduce((sum, arr) => sum + arr.length, 0),
      cold_corpus_tracked: watcherState.indexes.cold_corpus.length,
      bridge_results_tracked: (watcherState.indexes.bridge_results || []).length,
      bridge_heartbeats_tracked: (watcherState.indexes.bridge_heartbeats || []).length
    },
    bridge: {
      qiuqiu_status: watcherState.bridge.qiuqiu_status,
      last_heartbeat: watcherState.bridge.last_heartbeat,
      last_heartbeat_status: watcherState.bridge.last_heartbeat_status,
      last_result: watcherState.bridge.last_result,
      last_result_task_ref: watcherState.bridge.last_result_task_ref,
      total_results_received: watcherState.bridge.total_results_received,
      total_heartbeats_received: watcherState.bridge.total_heartbeats_received
    },
    recent_events: watcherState.events.slice(-20),
    timestamp: new Date().toISOString()
  };
}

/**
 * 手动触发一次扫描
 */
async function triggerScan() {
  logEvent('manual_trigger', '手动触发扫描');
  await runScan();
  return getStatus();
}

/**
 * 重置索引（下次扫描会将所有现有文件视为新文件）
 */
function resetIndex() {
  watcherState.indexes = {
    team_reports: {},
    team_receipts: {},
    cold_corpus: [],
    bridge_results: [],
    bridge_heartbeats: []
  };
  saveState();
  logEvent('index_reset', '索引已重置');
  return { reset: true };
}

/**
 * 获取桥接专属状态（秋秋通信通道详情）
 */
function getBridgeStatus() {
  const bridge = watcherState.bridge;
  // 计算秋秋是否在线（最后心跳在12小时内 = 在线，超过 = 可能离线）
  let online = false;
  if (bridge.last_heartbeat) {
    const lastHbTime = new Date(bridge.last_heartbeat).getTime();
    const now = Date.now();
    const twelveHours = 12 * 60 * 60 * 1000;
    online = (now - lastHbTime) < twelveHours;
  }

  return {
    channel: '暗核频道 · FS-DC-001',
    bridge_path: '/bridge/zhuyuan-qiuqiu/',
    qiuqiu: {
      status: bridge.qiuqiu_status,
      online,
      last_heartbeat: bridge.last_heartbeat,
      last_heartbeat_status: bridge.last_heartbeat_status
    },
    results: {
      last_received: bridge.last_result,
      last_task_ref: bridge.last_result_task_ref,
      total_received: bridge.total_results_received
    },
    indexes: {
      results_tracked: (watcherState.indexes.bridge_results || []).length,
      heartbeats_tracked: (watcherState.indexes.bridge_heartbeats || []).length
    },
    timestamp: new Date().toISOString()
  };
}

module.exports = {
  start,
  stop,
  getStatus,
  getBridgeStatus,
  triggerScan,
  resetIndex,
  runScan
};