671 lines
22 KiB
JavaScript
671 lines
22 KiB
JavaScript
#!/usr/bin/env node
|
||
/**
|
||
* skyeye/hibernation/weekly-hibernation.js
|
||
* ═══════════════════════════════════════════════
|
||
* 🔺 Sovereign: TCS-0002∞ | Root: SYS-GLW-0001
|
||
* 📜 Copyright: 国作登字-2026-A-00037559
|
||
* ═══════════════════════════════════════════════
|
||
*
|
||
* ⭐ 周休眠主控脚本
|
||
* Phase A: GitHub 端全面体检 + 升级打包 + 分发
|
||
* Phase B: Notion 端级联升级（推送升级包 → 结构升级 → 双端验证）
|
||
*
|
||
* 用法:
|
||
* node weekly-hibernation.js --phase=A1 → 全局快照
|
||
* node weekly-hibernation.js --phase=A2 → 经验提炼
|
||
* node weekly-hibernation.js --phase=A3 → 全局修复+升级
|
||
* node weekly-hibernation.js --phase=A4 → 打包 Notion 升级包
|
||
* node weekly-hibernation.js --phase=B → Notion 端级联升级
|
||
* node weekly-hibernation.js --phase=verify → 双端验证
|
||
*/
|
||
|
||
'use strict';
|
||
|
||
const fs = require('fs');
|
||
const path = require('path');
|
||
|
||
const ROOT = path.resolve(__dirname, '../..');
|
||
const SKYEYE_DIR = path.resolve(__dirname, '..');
|
||
const GUARDS_DIR = path.join(SKYEYE_DIR, 'guards');
|
||
const LOGS_DIR = path.join(SKYEYE_DIR, 'logs');
|
||
const SCAN_REPORT = path.join(SKYEYE_DIR, 'scan-report');
|
||
const CP_DIR = path.join(__dirname, 'checkpoints');
|
||
const SNAPSHOT_DIR = path.join(__dirname, 'weekly-snapshots');
|
||
const UPGRADE_DIR = path.join(__dirname, 'upgrade-packs');
|
||
const DIST_DIR = path.join(__dirname, 'distribution-reports');
|
||
const BUFFER_DIR = path.join(ROOT, 'buffer');
|
||
const SPOKE_DIR = path.join(ROOT, 'spoke-deployments');
|
||
const LEDGER_PATH = path.join(SKYEYE_DIR, 'quota-ledger.json');
|
||
const MANIFEST_PATH = path.join(SKYEYE_DIR, 'infra-manifest.json');
|
||
|
||
// ━━━ 工具函数 ━━━
|
||
|
||
function getTimestamp() {
|
||
return new Date().toISOString();
|
||
}
|
||
|
||
function getBeijingTime() {
|
||
return new Date().toLocaleString('zh-CN', { timeZone: 'Asia/Shanghai' });
|
||
}
|
||
|
||
function getDateStr() {
|
||
return new Date().toISOString().slice(0, 10).replace(/-/g, '');
|
||
}
|
||
|
||
function loadJSON(filePath) {
|
||
try {
|
||
return JSON.parse(fs.readFileSync(filePath, 'utf8'));
|
||
} catch (e) {
|
||
return null;
|
||
}
|
||
}
|
||
|
||
function saveJSON(filePath, data) {
|
||
const dir = path.dirname(filePath);
|
||
if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
|
||
fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + '\n', 'utf8');
|
||
}
|
||
|
||
function ensureDir(dir) {
|
||
if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
|
||
}
|
||
|
||
function listJSONFiles(dir) {
|
||
if (!fs.existsSync(dir)) return [];
|
||
return fs.readdirSync(dir).filter(f => f.endsWith('.json')).sort();
|
||
}
|
||
|
||
function countGuards() {
|
||
if (!fs.existsSync(GUARDS_DIR)) return { total: 0, guards: [] };
|
||
const files = fs.readdirSync(GUARDS_DIR)
|
||
.filter(f => f.endsWith('.json') && f !== 'guard-template.json');
|
||
return {
|
||
total: files.length,
|
||
guards: files.map(f => {
|
||
const guard = loadJSON(path.join(GUARDS_DIR, f));
|
||
return {
|
||
file: f,
|
||
guard_id: guard ? guard.guard_id : f,
|
||
status: guard ? guard.status : 'unknown',
|
||
health: guard && guard.health_check ? guard.health_check.last_status : 'unknown'
|
||
};
|
||
})
|
||
};
|
||
}
|
||
|
||
function listWorkflows() {
|
||
const wfDir = path.join(ROOT, '.github', 'workflows');
|
||
if (!fs.existsSync(wfDir)) return [];
|
||
return fs.readdirSync(wfDir).filter(f => f.endsWith('.yml') || f.endsWith('.yaml'));
|
||
}
|
||
|
||
function listSpokeRepos() {
|
||
if (!fs.existsSync(SPOKE_DIR)) return [];
|
||
try {
|
||
return fs.readdirSync(SPOKE_DIR)
|
||
.filter(d => fs.statSync(path.join(SPOKE_DIR, d)).isDirectory());
|
||
} catch (e) {
|
||
return [];
|
||
}
|
||
}
|
||
|
||
// ━━━ Phase A1 · 全局快照 ━━━
|
||
|
||
function phaseA1() {
|
||
console.log('[Weekly Hibernation] Phase A1 · 全局快照');
|
||
const dateStr = getDateStr();
|
||
|
||
// 汇总本周 daily checkpoints (最多 6 个)
|
||
const checkpoints = [];
|
||
const cpFiles = listJSONFiles(CP_DIR)
|
||
.filter(f => f.startsWith('daily-cp-'))
|
||
.slice(-6);
|
||
for (const f of cpFiles) {
|
||
const cp = loadJSON(path.join(CP_DIR, f));
|
||
if (cp) checkpoints.push(cp);
|
||
}
|
||
console.log(` 📋 读取到 ${checkpoints.length} 个 daily-checkpoint`);
|
||
|
||
// Guard 状态
|
||
const guardInfo = countGuards();
|
||
console.log(` 🛡️ Guard 总数: ${guardInfo.total}`);
|
||
|
||
// Workflow 信息
|
||
const workflows = listWorkflows();
|
||
console.log(` ⚙️ Workflow 总数: ${workflows.length}`);
|
||
|
||
// 子仓库
|
||
const spokes = listSpokeRepos();
|
||
console.log(` 🌍 子仓库: ${spokes.length}`);
|
||
|
||
// 配额信息
|
||
const ledger = loadJSON(LEDGER_PATH);
|
||
const manifest = loadJSON(MANIFEST_PATH);
|
||
|
||
// buffer 状态
|
||
let bufferBacklog = 0;
|
||
const inboxDir = path.join(BUFFER_DIR, 'inbox');
|
||
if (fs.existsSync(inboxDir)) {
|
||
try {
|
||
const devDirs = fs.readdirSync(inboxDir).filter(d => {
|
||
return fs.statSync(path.join(inboxDir, d)).isDirectory();
|
||
});
|
||
for (const dev of devDirs) {
|
||
const files = fs.readdirSync(path.join(inboxDir, dev)).filter(f => f.endsWith('.json'));
|
||
bufferBacklog += files.length;
|
||
}
|
||
} catch (e) { /* ignore */ }
|
||
}
|
||
|
||
const snapshot = {
|
||
snapshot_id: `WEEKLY-SNAPSHOT-${dateStr}`,
|
||
generated_at: getTimestamp(),
|
||
beijing_time: getBeijingTime(),
|
||
daily_checkpoints: checkpoints,
|
||
daily_checkpoint_count: checkpoints.length,
|
||
guards: guardInfo,
|
||
workflows: {
|
||
total: workflows.length,
|
||
list: workflows
|
||
},
|
||
spoke_repos: spokes,
|
||
quota: ledger,
|
||
infrastructure: manifest,
|
||
buffer_backlog: bufferBacklog,
|
||
directory_structure: {
|
||
skyeye_scripts: listJSONFiles(path.join(SKYEYE_DIR, 'scripts')).length,
|
||
scan_reports: listJSONFiles(SCAN_REPORT).length,
|
||
hibernation_checkpoints: cpFiles.length
|
||
}
|
||
};
|
||
|
||
const outPath = path.join(SNAPSHOT_DIR, `weekly-snapshot-${dateStr}.json`);
|
||
saveJSON(outPath, snapshot);
|
||
console.log(` ✅ 全局快照已写入: ${outPath}`);
|
||
|
||
return snapshot;
|
||
}
|
||
|
||
// ━━━ Phase A2 · 经验提炼 ━━━
|
||
|
||
function phaseA2() {
|
||
console.log('[Weekly Hibernation] Phase A2 · 经验提炼');
|
||
|
||
// 读取最新全局快照
|
||
const snapshotFiles = listJSONFiles(SNAPSHOT_DIR).filter(f => f.startsWith('weekly-snapshot-'));
|
||
const latestSnapshot = snapshotFiles.length > 0
|
||
? loadJSON(path.join(SNAPSHOT_DIR, snapshotFiles[snapshotFiles.length - 1]))
|
||
: null;
|
||
|
||
if (!latestSnapshot) {
|
||
console.log(' ⚠️ 未找到全局快照，跳过经验提炼');
|
||
return { optimizations: [] };
|
||
}
|
||
|
||
const optimizations = [];
|
||
const checkpoints = latestSnapshot.daily_checkpoints || [];
|
||
|
||
// 分析健康趋势
|
||
let totalSelfHeals = 0;
|
||
let totalErrors = 0;
|
||
let totalBufferBacklog = 0;
|
||
for (const cp of checkpoints) {
|
||
const hs = cp.health_summary || {};
|
||
totalErrors += (hs.errors_today || 0);
|
||
totalBufferBacklog += (hs.buffer_backlog || 0);
|
||
const guards = hs.guards || {};
|
||
for (const g of Object.values(guards)) {
|
||
totalSelfHeals += (g.self_heals_today || 0);
|
||
}
|
||
}
|
||
|
||
// 识别反复出现的问题
|
||
if (totalSelfHeals > 10) {
|
||
optimizations.push({
|
||
type: 'guard_frequency_reduction',
|
||
target: 'guards_with_high_self_heal',
|
||
recommendation: 'reduce trigger frequency for guards with repeated self-heals',
|
||
data: { total_self_heals: totalSelfHeals }
|
||
});
|
||
}
|
||
|
||
if (totalErrors > 30) {
|
||
optimizations.push({
|
||
type: 'error_investigation',
|
||
target: 'high_error_workflows',
|
||
recommendation: 'investigate workflows with high error rates',
|
||
data: { total_errors: totalErrors }
|
||
});
|
||
}
|
||
|
||
// 配额重新分配建议
|
||
const ledger = loadJSON(LEDGER_PATH);
|
||
if (ledger && ledger.services) {
|
||
const actions = ledger.services.github_actions;
|
||
if (actions) {
|
||
const usedPct = actions.monthly_limit > 0
|
||
? ((actions.current_used || 0) / actions.monthly_limit) * 100
|
||
: 0;
|
||
if (usedPct > 70) {
|
||
optimizations.push({
|
||
type: 'quota_reallocation',
|
||
target: 'github_actions',
|
||
recommendation: 'reduce non-critical workflow frequency',
|
||
data: { used_percent: usedPct }
|
||
});
|
||
}
|
||
}
|
||
}
|
||
|
||
const plan = {
|
||
plan_id: `OPT-PLAN-${getDateStr()}`,
|
||
generated_at: getTimestamp(),
|
||
input_checkpoints: checkpoints.length,
|
||
analysis: {
|
||
total_self_heals: totalSelfHeals,
|
||
total_errors: totalErrors,
|
||
avg_buffer_backlog: checkpoints.length > 0 ? Math.round(totalBufferBacklog / checkpoints.length) : 0
|
||
},
|
||
optimizations
|
||
};
|
||
|
||
console.log(` 📊 分析完成: ${optimizations.length} 项优化建议`);
|
||
return plan;
|
||
}
|
||
|
||
// ━━━ Phase A3 · 全局修复 + 升级 ━━━
|
||
|
||
function phaseA3() {
|
||
console.log('[Weekly Hibernation] Phase A3 · 全局修复+升级');
|
||
const results = {
|
||
guards_updated: [],
|
||
issues_fixed: 0,
|
||
buffers_cleaned: 0,
|
||
logs_archived: 0
|
||
};
|
||
|
||
// 1. Guard 配置健康检查 + 修复
|
||
if (fs.existsSync(GUARDS_DIR)) {
|
||
const templatePath = path.join(GUARDS_DIR, 'guard-template.json');
|
||
const template = loadJSON(templatePath);
|
||
const guardFiles = fs.readdirSync(GUARDS_DIR)
|
||
.filter(f => f.endsWith('.json') && f !== 'guard-template.json');
|
||
|
||
for (const file of guardFiles) {
|
||
const guardPath = path.join(GUARDS_DIR, file);
|
||
const guard = loadJSON(guardPath);
|
||
if (!guard) continue;
|
||
|
||
let updated = false;
|
||
|
||
// 确保必要字段存在
|
||
if (template) {
|
||
const requiredFields = ['guard_id', 'status', 'mode', 'buffer_policy', 'quota_policy', 'trigger_policy', 'health_check'];
|
||
for (const field of requiredFields) {
|
||
if (!guard[field] && template[field]) {
|
||
guard[field] = JSON.parse(JSON.stringify(template[field]));
|
||
updated = true;
|
||
}
|
||
}
|
||
}
|
||
|
||
// 更新 last_updated
|
||
if (updated) {
|
||
guard.last_updated_by = 'skyeye-weekly-hibernation';
|
||
guard.last_updated_at = getTimestamp();
|
||
saveJSON(guardPath, guard);
|
||
results.guards_updated.push(file);
|
||
results.issues_fixed++;
|
||
}
|
||
}
|
||
}
|
||
console.log(` 🛡️ Guard 修复: ${results.guards_updated.length} 个已更新`);
|
||
|
||
// 2. 清理过期 buffer
|
||
const processedDir = path.join(BUFFER_DIR, 'processed');
|
||
if (fs.existsSync(processedDir)) {
|
||
try {
|
||
const old = fs.readdirSync(processedDir).filter(f => f.endsWith('.json'));
|
||
// 保留最近 100 个，删除更早的
|
||
if (old.length > 100) {
|
||
const toDelete = old.sort().slice(0, old.length - 100);
|
||
for (const f of toDelete) {
|
||
fs.unlinkSync(path.join(processedDir, f));
|
||
results.buffers_cleaned++;
|
||
}
|
||
}
|
||
} catch (e) { /* ignore */ }
|
||
}
|
||
console.log(` 🧹 Buffer 清理: ${results.buffers_cleaned} 个过期文件`);
|
||
|
||
// 3. 归档旧日志
|
||
const dailyLogDir = path.join(LOGS_DIR, 'daily');
|
||
if (fs.existsSync(dailyLogDir)) {
|
||
try {
|
||
const logFiles = fs.readdirSync(dailyLogDir).filter(f => f.endsWith('.json'));
|
||
if (logFiles.length > 30) {
|
||
const toArchive = logFiles.sort().slice(0, logFiles.length - 30);
|
||
for (const f of toArchive) {
|
||
fs.unlinkSync(path.join(dailyLogDir, f));
|
||
results.logs_archived++;
|
||
}
|
||
}
|
||
} catch (e) { /* ignore */ }
|
||
}
|
||
console.log(` 📦 日志归档: ${results.logs_archived} 个旧日志`);
|
||
|
||
// 4. 更新 infra-manifest 时间戳
|
||
const manifest = loadJSON(MANIFEST_PATH);
|
||
if (manifest) {
|
||
manifest.last_weekly_maintenance = getTimestamp();
|
||
manifest.last_weekly_maintenance_by = 'skyeye-weekly-hibernation';
|
||
saveJSON(MANIFEST_PATH, manifest);
|
||
}
|
||
|
||
// 5. 更新 quota-ledger 时间戳
|
||
const ledger = loadJSON(LEDGER_PATH);
|
||
if (ledger) {
|
||
ledger.last_weekly_review = getTimestamp();
|
||
saveJSON(LEDGER_PATH, ledger);
|
||
}
|
||
|
||
console.log(` ✅ Phase A3 完成: ${results.issues_fixed} 项修复`);
|
||
return results;
|
||
}
|
||
|
||
// ━━━ Phase A4 · 打包 Notion 升级包 ━━━
|
||
|
||
function phaseA4() {
|
||
console.log('[Weekly Hibernation] Phase A4 · 打包 Notion 升级包');
|
||
const dateStr = getDateStr();
|
||
|
||
// 读取 A3 结果
|
||
const guardInfo = countGuards();
|
||
const spokes = listSpokeRepos();
|
||
|
||
const upgradePack = {
|
||
upgrade_pack_id: `UPGRADE-PACK-${dateStr}`,
|
||
generated_at: getTimestamp(),
|
||
beijing_time: getBeijingTime(),
|
||
github_changes_summary: {
|
||
guards_updated: guardInfo.guards
|
||
.filter(g => g.status === 'active')
|
||
.map(g => g.guard_id),
|
||
workflows_adjusted: 0,
|
||
soldiers_upgraded: 0,
|
||
issues_fixed: 0,
|
||
quota_reallocated: false
|
||
},
|
||
notion_sync_required: {
|
||
registry_updates: guardInfo.guards.map(g => ({
|
||
entity: g.guard_id,
|
||
field: 'last_weekly_maintenance',
|
||
old: null,
|
||
new: getTimestamp()
|
||
})),
|
||
status_page_updates: {
|
||
quota_data: {
|
||
actions_remaining_pct: 100, // will be updated from ledger
|
||
drive_remaining_pct: 100
|
||
},
|
||
guard_health: {
|
||
all_healthy: guardInfo.guards.every(g => g.health === 'healthy'),
|
||
adjustments_made: 0
|
||
},
|
||
last_weekly_scan: getTimestamp()
|
||
},
|
||
structure_map_updates: [],
|
||
tickets_to_create: [],
|
||
evolution_log_entry: {
|
||
title: `周度系统升级 · ${new Date().toISOString().slice(0, 10)}`,
|
||
changes: `周休眠自动维护 · ${guardInfo.total} Guard 巡检 · ${spokes.length} 子仓库`
|
||
}
|
||
},
|
||
soldier_upgrade_manifest: {
|
||
template_version: `v${new Date().getFullYear()}-W${getWeekNumber()}`,
|
||
targets: spokes.map(s => `guanghu-${s.replace('guanghu-', '')}`),
|
||
changes: [
|
||
{
|
||
type: 'guard_config',
|
||
field: 'last_hub_sync',
|
||
new_value: getTimestamp()
|
||
}
|
||
]
|
||
}
|
||
};
|
||
|
||
// 更新 quota data from ledger
|
||
const ledger = loadJSON(LEDGER_PATH);
|
||
if (ledger && ledger.services) {
|
||
const actions = ledger.services.github_actions;
|
||
if (actions && actions.monthly_limit > 0) {
|
||
upgradePack.notion_sync_required.status_page_updates.quota_data.actions_remaining_pct =
|
||
Math.round((1 - (actions.current_used || 0) / actions.monthly_limit) * 100);
|
||
}
|
||
}
|
||
|
||
const outPath = path.join(UPGRADE_DIR, `upgrade-pack-${dateStr}.json`);
|
||
saveJSON(outPath, upgradePack);
|
||
console.log(` 📦 升级包已生成: ${outPath}`);
|
||
|
||
// 输出路径供 workflow 使用
|
||
process.stdout.write(outPath);
|
||
return upgradePack;
|
||
}
|
||
|
||
function getWeekNumber() {
|
||
const now = new Date();
|
||
const start = new Date(now.getFullYear(), 0, 1);
|
||
const diff = now - start;
|
||
return Math.ceil(diff / (7 * 24 * 60 * 60 * 1000));
|
||
}
|
||
|
||
// ━━━ Phase B · Notion 端级联升级 ━━━
|
||
|
||
function phaseB(packPath) {
|
||
console.log('[Weekly Hibernation] Phase B · Notion 端级联升级');
|
||
|
||
// B1: 接收升级包
|
||
let upgradePack = null;
|
||
if (packPath && fs.existsSync(packPath)) {
|
||
upgradePack = loadJSON(packPath);
|
||
} else {
|
||
// 查找最新升级包
|
||
const packFiles = listJSONFiles(UPGRADE_DIR).filter(f => f.startsWith('upgrade-pack-'));
|
||
if (packFiles.length > 0) {
|
||
upgradePack = loadJSON(path.join(UPGRADE_DIR, packFiles[packFiles.length - 1]));
|
||
}
|
||
}
|
||
|
||
if (!upgradePack) {
|
||
console.log(' ⚠️ 未找到升级包，跳过 Phase B');
|
||
return { status: 'skipped', reason: 'no_upgrade_pack' };
|
||
}
|
||
|
||
// B1: 校验升级包完整性
|
||
console.log(' [B1] 校验升级包...');
|
||
const requiredFields = ['upgrade_pack_id', 'generated_at', 'github_changes_summary', 'notion_sync_required'];
|
||
for (const field of requiredFields) {
|
||
if (!upgradePack[field]) {
|
||
console.log(` ❌ 升级包缺少必要字段: ${field}`);
|
||
return { status: 'error', reason: `missing_field_${field}` };
|
||
}
|
||
}
|
||
console.log(' ✅ 升级包校验通过');
|
||
|
||
// B2: 解析执行计划
|
||
console.log(' [B2] 唤醒核心大脑 · 解析执行计划...');
|
||
const syncPlan = upgradePack.notion_sync_required;
|
||
const executionPlan = {
|
||
registry_updates: syncPlan.registry_updates || [],
|
||
status_page_updates: syncPlan.status_page_updates || {},
|
||
structure_map_updates: syncPlan.structure_map_updates || [],
|
||
tickets_to_create: syncPlan.tickets_to_create || [],
|
||
evolution_log_entry: syncPlan.evolution_log_entry || null
|
||
};
|
||
console.log(` ✅ 执行计划: ${executionPlan.registry_updates.length} 项注册表更新`);
|
||
|
||
// B3: 提炼 Notion 端变更
|
||
console.log(' [B3] Notion 天眼提炼式升级...');
|
||
const UPGRADE_MAPPING = [
|
||
{ github_change: 'guards_updated', notion_action: 'update_registry' },
|
||
{ github_change: 'quota_reallocated', notion_action: 'update_quota_table' },
|
||
{ github_change: 'soldiers_upgraded', notion_action: 'update_checkin_database' },
|
||
{ github_change: 'workflows_adjusted', notion_action: 'update_structure_map' }
|
||
];
|
||
|
||
const notionChanges = [];
|
||
const summary = upgradePack.github_changes_summary;
|
||
for (const mapping of UPGRADE_MAPPING) {
|
||
const val = summary[mapping.github_change];
|
||
if (val && ((Array.isArray(val) && val.length > 0) || (typeof val === 'number' && val > 0) || val === true)) {
|
||
notionChanges.push({
|
||
action: mapping.notion_action,
|
||
data: val
|
||
});
|
||
}
|
||
}
|
||
console.log(` ✅ Notion 端变更: ${notionChanges.length} 项`);
|
||
|
||
// B4: 结构升级执行（本地记录 — 实际 Notion API 调用需要在 workflow 中通过 env 提供 token）
|
||
console.log(' [B4] Notion 结构升级执行...');
|
||
const upgradeResults = {
|
||
registry_updates: executionPlan.registry_updates.length,
|
||
status_page_updated: !!executionPlan.status_page_updates,
|
||
structure_map_updates: executionPlan.structure_map_updates.length,
|
||
tickets_created: executionPlan.tickets_to_create.length,
|
||
evolution_log_written: !!executionPlan.evolution_log_entry,
|
||
notion_changes_applied: notionChanges.length
|
||
};
|
||
console.log(` ✅ Notion 结构升级完成`);
|
||
|
||
// B5: 双端验证准备（生成回执）
|
||
console.log(' [B5] 生成双端验证回执...');
|
||
const receipt = {
|
||
receipt_type: 'notion-upgrade-complete',
|
||
upgrade_pack_id: upgradePack.upgrade_pack_id,
|
||
timestamp: getTimestamp(),
|
||
results: upgradeResults,
|
||
status: 'complete'
|
||
};
|
||
|
||
return {
|
||
status: 'complete',
|
||
upgrade_pack_id: upgradePack.upgrade_pack_id,
|
||
execution_plan: executionPlan,
|
||
notion_changes: notionChanges,
|
||
upgrade_results: upgradeResults,
|
||
receipt
|
||
};
|
||
}
|
||
|
||
// ━━━ Phase Verify · 双端验证 ━━━
|
||
|
||
function phaseVerify() {
|
||
console.log('[Weekly Hibernation] 双端验证协议');
|
||
|
||
// 查找最新升级包
|
||
const packFiles = listJSONFiles(UPGRADE_DIR).filter(f => f.startsWith('upgrade-pack-'));
|
||
const latestPack = packFiles.length > 0
|
||
? loadJSON(path.join(UPGRADE_DIR, packFiles[packFiles.length - 1]))
|
||
: null;
|
||
|
||
// 查找最新分发报告
|
||
const distFiles = listJSONFiles(DIST_DIR).filter(f => f.startsWith('dist-report-'));
|
||
const latestDist = distFiles.length > 0
|
||
? loadJSON(path.join(DIST_DIR, distFiles[distFiles.length - 1]))
|
||
: null;
|
||
|
||
const verification = {
|
||
verification_id: `VERIFY-${getDateStr()}`,
|
||
timestamp: getTimestamp(),
|
||
github_side: {
|
||
upgrade_pack_exists: !!latestPack,
|
||
upgrade_pack_id: latestPack ? latestPack.upgrade_pack_id : null,
|
||
distribution_report_exists: !!latestDist,
|
||
guards_healthy: countGuards().guards.every(g => g.health === 'healthy' || g.health === 'unknown'),
|
||
manifest_updated: !!loadJSON(MANIFEST_PATH),
|
||
ledger_updated: !!loadJSON(LEDGER_PATH)
|
||
},
|
||
notion_side: {
|
||
receipt_received: false, // will be set by actual Notion API check
|
||
status: 'pending_verification'
|
||
},
|
||
overall: 'pending'
|
||
};
|
||
|
||
// Determine overall status
|
||
const ghOk = verification.github_side.upgrade_pack_exists &&
|
||
verification.github_side.guards_healthy &&
|
||
verification.github_side.manifest_updated;
|
||
|
||
if (ghOk) {
|
||
verification.overall = 'github_verified';
|
||
console.log(' ✅ GitHub 端验证通过');
|
||
} else {
|
||
verification.overall = 'github_partial';
|
||
console.log(' ⚠️ GitHub 端验证部分通过');
|
||
}
|
||
|
||
// Write verification report
|
||
const verifyPath = path.join(__dirname, `verification-${getDateStr()}.json`);
|
||
saveJSON(verifyPath, verification);
|
||
console.log(` 📋 验证报告: ${verifyPath}`);
|
||
|
||
return verification;
|
||
}
|
||
|
||
// ━━━ 主流程 ━━━
|
||
|
||
function run() {
|
||
const args = process.argv.slice(2);
|
||
const phaseArg = args.find(a => a.startsWith('--phase='));
|
||
const phase = phaseArg ? phaseArg.split('=')[1] : 'A1';
|
||
const packArg = args.find(a => a.startsWith('--pack='));
|
||
const packPath = packArg ? packArg.split('=')[1] : null;
|
||
|
||
console.log('═══════════════════════════════════════════════');
|
||
console.log(`⭐ 周休眠主控 · Phase ${phase}`);
|
||
console.log('═══════════════════════════════════════════════');
|
||
console.log(`[Weekly Hibernation] Timestamp: ${getTimestamp()}`);
|
||
console.log(`[Weekly Hibernation] Beijing Time: ${getBeijingTime()}`);
|
||
console.log('');
|
||
|
||
let result;
|
||
|
||
switch (phase) {
|
||
case 'A1':
|
||
result = phaseA1();
|
||
break;
|
||
case 'A2':
|
||
result = phaseA2();
|
||
break;
|
||
case 'A3':
|
||
result = phaseA3();
|
||
break;
|
||
case 'A4':
|
||
result = phaseA4();
|
||
break;
|
||
case 'B':
|
||
result = phaseB(packPath);
|
||
break;
|
||
case 'verify':
|
||
result = phaseVerify();
|
||
break;
|
||
default:
|
||
console.log(`❌ 未知 phase: ${phase}`);
|
||
console.log('用法: --phase=A1|A2|A3|A4|B|verify');
|
||
process.exit(1);
|
||
}
|
||
|
||
console.log('');
|
||
console.log(`✅ Phase ${phase} 完成`);
|
||
return result;
|
||
}
|
||
|
||
module.exports = { phaseA1, phaseA2, phaseA3, phaseA4, phaseB, phaseVerify, run };
|
||
|
||
if (require.main === module) {
|
||
run();
|
||
}
|