import * as fs from 'fs';

import * as path from 'path';

import { fileURLToPath } from 'url';

import Parser from 'rss-parser';

const __filename = fileURLToPath(import.meta.url);

const __dirname = path.dirname(__filename);

// ============================================================================

// Type Definitions

// ============================================================================

interface BlogPost {

title: string;

link: string;

date: string;

}

/**

* Desktop index.json structure from desktop.dl.hagicode.com/index.json

*/

interface DesktopIndex {

updatedAt: string;

versions: Array<{

version: string;

files: string[];

assets: Array<{

name: string;

path: string;

size: number;

lastModified: string;

}>;

}>;

channels: {

[channelName: string]: {

latest: string;

versions: string[];

};

};

}

/**

* Server index.json structure from server.dl.hagicode.com/index.json

*/

interface ServerIndex {

updatedAt: string;

versions: Array<{

version: string;

files: string[];

assets: Array<{

name: string;

path: string;

size: number;

lastModified: string;

}>;

}>;

channels: {

[channelName: string]: {

latest: string;

versions: string[];

};

};

}

/**

* Represents a version extracted from a specific channel

*/

interface ChannelVersion {

channel: string;

version: string;

product: 'desktop' | 'server';

}

/**

* Configuration for generating version badges

*/

interface BadgeConfig {

label: string;

color: string;

}

// ============================================================================

// Constants

// ============================================================================

const RSS_URL = 'https://docs.hagicode.com/blog/rss.xml';

const README_PATH = path.join(__dirname, 'profile', 'README.md');

const MAX_POSTS = 10;

const DESKTOP_INDEX_URL = 'https://index.hagicode.com/desktop/index.json';

const SERVER_INDEX_URL = 'https://index.hagicode.com/server/index.json';

/**

* Badge configurations for different product-channel combinations

* Stable versions use blue, beta versions use orange

*/

const BADGE_CONFIGS: Record<string, BadgeConfig> = {

'desktop-stable': { label: 'Desktop Stable', color: 'blue' },

'desktop-beta': { label: 'Desktop Beta', color: 'orange' },

'server-stable': { label: 'Server Stable', color: 'blue' },

'server-beta': { label: 'Server Beta', color: 'orange' }

};

// ============================================================================

// RSS Fetching Functions

// ============================================================================

/**

* Fetches and parses the RSS feed from the blog

*/

async function fetchRSS(): Promise<BlogPost[]> {

console.log(`Fetching RSS from ${RSS_URL}...`);

const parser = new Parser();

try {

const feed = await parser.parseURL(RSS_URL);

console.log(`Successfully fetched ${feed.items.length} items from RSS`);

const posts: BlogPost[] = feed.items.slice(0, MAX_POSTS).map(item => ({

title: item.title ?? 'Untitled',

link: item.link ?? '',

date: item.pubDate ? new Date(item.pubDate).toLocaleDateString('zh-CN') : ''

}));

return posts;

} catch (error) {

console.error('Failed to fetch RSS:', error);

throw new Error(`RSS fetch failed: ${error instanceof Error ? error.message : 'Unknown error'}`);

}

}

function generateBlogTable(posts: BlogPost[]): string {

const header = '| 日期 | 标题 |\n|------|------|';

const rows = posts.map(post => {

const date = post.date || 'N/A';

const title = `[${post.title}](${post.link})`;

return `| ${date} | ${title} |`;

});

return `${header}\n${rows.join('\n')}`;

}

function updateReadme(blogTable: string): void {

console.log('Reading existing README...');

if (!fs.existsSync(README_PATH)) {

throw new Error(`README not found at ${README_PATH}`);

}

let content = fs.readFileSync(README_PATH, 'utf-8');

const startMarker = '<!-- blog-posts-start -->';

const endMarker = '<!-- blog-posts-end -->';

const startIndex = content.indexOf(startMarker);

const endIndex = content.indexOf(endMarker);

if (startIndex === -1 || endIndex === -1) {

throw new Error('Placeholder markers not found in README');

}

const before = content.substring(0, startIndex + startMarker.length);

const after = content.substring(endIndex);

content = `${before}\n${blogTable}\n${after}`;

fs.writeFileSync(README_PATH, content, 'utf-8');

console.log('README updated successfully');

}

// ============================================================================

// Version Fetching Functions

// ============================================================================

/**

* Fetches all channel versions from Desktop index.json

* @returns Array of ChannelVersion objects for Desktop

*/

async function fetchDesktopVersions(): Promise<ChannelVersion[]> {

console.log(`Fetching Desktop index from ${DESKTOP_INDEX_URL}...`);

try {

const response = await fetch(DESKTOP_INDEX_URL);

if (!response.ok) {

throw new Error(`HTTP ${response.status}: ${response.statusText}`);

}

const index: DesktopIndex = await response.json();

// Validate JSON structure

if (!index.channels) {

throw new Error('channels not found in Desktop index');

}

const versions: ChannelVersion[] = [];

// Extract all channel versions

for (const [channelName, channelData] of Object.entries(index.channels)) {

if (channelData.latest) {

versions.push({

channel: channelName,

version: channelData.latest,

product: 'desktop'

});

}

}

console.log(`Found ${versions.length} Desktop channel(s): ${versions.map(v => `${v.channel}:${v.version}`).join(', ')}`);

return versions;

} catch (error) {

console.error('Failed to fetch Desktop versions:', error);

throw new Error(`Desktop version fetch failed: ${error instanceof Error ? error.message : 'Unknown error'}`);

}

}

/**

* Fetches all channel versions from Server index.json

* @returns Array of ChannelVersion objects for Server

*/

async function fetchServerVersions(): Promise<ChannelVersion[]> {

console.log(`Fetching Server index from ${SERVER_INDEX_URL}...`);

try {

const response = await fetch(SERVER_INDEX_URL);

if (!response.ok) {

throw new Error(`HTTP ${response.status}: ${response.statusText}`);

}

const index: ServerIndex = await response.json();

// Validate JSON structure

if (!index.channels) {

throw new Error('channels not found in Server index');

}

const versions: ChannelVersion[] = [];

// Extract all channel versions

for (const [channelName, channelData] of Object.entries(index.channels)) {

if (channelData.latest) {

versions.push({

channel: channelName,

version: channelData.latest,

product: 'server'

});

}

}

console.log(`Found ${versions.length} Server channel(s): ${versions.map(v => `${v.channel}:${v.version}`).join(', ')}`);

return versions;

} catch (error) {

console.error('Failed to fetch Server versions:', error);

throw new Error(`Server version fetch failed: ${error instanceof Error ? error.message : 'Unknown error'}`);

}

}

// ============================================================================

// Badge Generation Functions

// ============================================================================

/**

* Generates Markdown badge URLs for channel versions

* @param versions Array of channel versions

* @returns Array of badge Markdown strings

*/

function generateChannelBadges(versions: ChannelVersion[]): string[] {

const badges: string[] = [];

for (const versionData of versions) {

const configKey = `${versionData.product}-${versionData.channel}`;

const config = BADGE_CONFIGS[configKey];

if (!config) {

console.warn(`No badge config found for ${configKey}, skipping`);

continue;

}

// Spaces in label should be URL-encoded

const escapedLabel = config.label.replace(/ /g, '%20');

// Version should be URL-encoded (hyphens don't need escaping in URL, but spaces do)

const encodedVersion = encodeURIComponent(versionData.version);

const badgeUrl = ``;

badges.push(badgeUrl);

}

return badges;

}

/**

* Updates version badges in README.md

* @param badges Array of badge Markdown strings to update

*/

function updateChannelBadges(badges: string[]): void {

console.log('Reading existing README...');

if (!fs.existsSync(README_PATH)) {

throw new Error(`README not found at ${README_PATH}`);

}

let content = fs.readFileSync(README_PATH, 'utf-8');

let updatedCount = 0;

// Update each badge separately using regex with channel label matching

for (const badge of badges) {

// Extract label and color from badge for pattern matching

const badgeMatch = badge.match(/!\[([^\]]+)\]\(https:\/\/img\.shields\.io\/badge\/([^\)]+)\)/);

if (!badgeMatch) {

console.warn(`Could not parse badge: ${badge}`);

continue;

}

const label = badgeMatch[1];

const badgeUrlPattern = badgeMatch[2];

// Create regex that matches badges with this label regardless of version/color

// Handle both space and %20 encoding for spaces in labels

const escapedLabel = escapeRegex(label);

const encodedLabel = label.replace(/ /g, '%20').replace(/[.*+?^${}()|[\]\\]/g, '\\$&');

const regex = new RegExp(`!\\[${escapedLabel}\\]\\(https://img\\.shields\\.io/badge/(?:${escapedLabel}|${encodedLabel})-[^\)]+\\)`, 'g');

const oldContent = content;

content = content.replace(regex, badge);

if (oldContent !== content) {

updatedCount++;

}

}

if (updatedCount > 0) {

fs.writeFileSync(README_PATH, content, 'utf-8');

console.log(`Updated ${updatedCount} version badge(s)`);

} else {

console.warn('No version badges found to update');

}

}

/**

* Escapes special regex characters

*/

function escapeRegex(str: string): string {

return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');

}

// ============================================================================

// Main Function

// ============================================================================

async function main(): Promise<void> {

console.log('=== Starting Sync Job ===');

try {

// Blog RSS Sync

console.log('\n--- Blog RSS Sync ---');

const posts = await fetchRSS();

if (posts.length > 0) {

const blogTable = generateBlogTable(posts);

updateReadme(blogTable);

console.log('=== Blog RSS Sync Completed ===\n');

} else {

console.log('No blog posts found, skipping RSS update\n');

}

// Version Sync with error isolation

console.log('--- Version Sync ---');

let hasVersionErrors = false;

// Sync Desktop versions

try {

const desktopVersions = await fetchDesktopVersions();

if (desktopVersions.length > 0) {

const desktopBadges = generateChannelBadges(desktopVersions);

updateChannelBadges(desktopBadges);

}

} catch (error) {

console.error('Desktop version sync failed:', error);

hasVersionErrors = true;

}

// Sync Server versions (independent of Desktop)

try {

const serverVersions = await fetchServerVersions();

if (serverVersions.length > 0) {

const serverBadges = generateChannelBadges(serverVersions);

updateChannelBadges(serverBadges);

}

} catch (error) {

console.error('Server version sync failed:', error);

hasVersionErrors = true;

}

if (hasVersionErrors) {

console.warn('=== Version Sync Completed with Errors ===\n');

} else {

console.log('=== Version Sync Completed ===\n');

}

console.log('=== All Sync Jobs Completed ===');

} catch (error) {

console.error('Fatal error during sync:', error);

process.exit(1);

}

}

main();