hx-cdn-forge 2.0.0

package/src/core/__tests__/cdnNodes.test.ts

@@ -0,0 +1,142 @@
+import {
+  CDN_NODE_PRESETS,
+  DEFAULT_GITHUB_CDN_NODES,
+  createWorkerNode,
+  CDNTester,
+  getSortedNodesWithLatency,
+} from '../cdnNodes';
+import { createForgeConfig, normalizeConfig } from '../config';
+import type { LatencyResult } from '../../types';
+
+describe('CDN_NODE_PRESETS', () => {
+  const ctx = { user: 'owner', repo: 'repo', ref: 'v1.0' };
+
+  test('jsDelivr main builds correct URL', () => {
+    const url = CDN_NODE_PRESETS.jsdelivr_main.buildUrl(ctx, '/docs/readme.md');
+    expect(url).toBe('https://cdn.jsdelivr.net/gh/owner/repo@v1.0/docs/readme.md');
+  });
+
+  test('jsDelivr fastly builds correct URL', () => {
+    const url = CDN_NODE_PRESETS.jsdelivr_fastly.buildUrl(ctx, '/file.txt');
+    expect(url).toBe('https://fastly.jsdelivr.net/gh/owner/repo@v1.0/file.txt');
+  });
+
+  test('GitHub Raw builds correct URL', () => {
+    const url = CDN_NODE_PRESETS.github_raw.buildUrl(ctx, '/README.md');
+    expect(url).toBe('https://raw.githubusercontent.com/owner/repo/v1.0/README.md');
+  });
+
+  test('JSD Mirror builds correct URL', () => {
+    const url = CDN_NODE_PRESETS.jsd_mirror.buildUrl(ctx, '/data.json');
+    expect(url).toBe('https://cdn.jsdmirror.com/gh/owner/repo@v1.0/data.json');
+  });
+
+  test('handles path without leading slash', () => {
+    const url = CDN_NODE_PRESETS.jsdelivr_main.buildUrl(ctx, 'no-slash.txt');
+    expect(url).toBe('https://cdn.jsdelivr.net/gh/owner/repo@v1.0/no-slash.txt');
+  });
+});
+
+describe('DEFAULT_GITHUB_CDN_NODES', () => {
+  test('has 6 default nodes', () => {
+    expect(DEFAULT_GITHUB_CDN_NODES).toHaveLength(6);
+  });
+
+  test('all nodes have required fields', () => {
+    for (const node of DEFAULT_GITHUB_CDN_NODES) {
+      expect(node.id).toBeTruthy();
+      expect(node.name).toBeTruthy();
+      expect(node.baseUrl).toBeTruthy();
+      expect(node.region).toBeTruthy();
+      expect(typeof node.buildUrl).toBe('function');
+      expect(typeof node.maxFileSize).toBe('number');
+      expect(typeof node.supportsRange).toBe('boolean');
+    }
+  });
+});
+
+describe('createWorkerNode', () => {
+  test('creates valid node', () => {
+    const node = createWorkerNode('my.workers.dev');
+    expect(node.id).toBe('cf-worker-my-workers-dev');
+    expect(node.name).toContain('my.workers.dev');
+    expect(node.baseUrl).toBe('https://my.workers.dev');
+    expect(node.maxFileSize).toBe(-1);
+    expect(node.supportsRange).toBe(true);
+  });
+
+  test('builds correct proxy URL', () => {
+    const node = createWorkerNode('proxy.example.com');
+    const ctx = { user: 'u', repo: 'r', ref: 'main' };
+    const url = node.buildUrl(ctx, '/file.txt');
+    expect(url).toBe('https://proxy.example.com/https://raw.githubusercontent.com/u/r/main/file.txt');
+  });
+});
+
+describe('CDNTester', () => {
+  test('getBestNodeId finds lowest latency', () => {
+    const tester = new CDNTester();
+    const results: LatencyResult[] = [
+      { nodeId: 'slow', latency: 500, success: true, timestamp: 1 },
+      { nodeId: 'fast', latency: 50, success: true, timestamp: 1 },
+      { nodeId: 'mid', latency: 200, success: true, timestamp: 1 },
+      { nodeId: 'fail', latency: -1, success: false, timestamp: 1 },
+    ];
+    expect(tester.getBestNodeId(results)).toBe('fast');
+  });
+
+  test('getBestNodeId returns null if all failed', () => {
+    const tester = new CDNTester();
+    const results: LatencyResult[] = [
+      { nodeId: 'a', latency: -1, success: false, timestamp: 1 },
+      { nodeId: 'b', latency: -1, success: false, timestamp: 1 },
+    ];
+    expect(tester.getBestNodeId(results)).toBeNull();
+  });
+});
+
+describe('getSortedNodesWithLatency', () => {
+  test('sorts by latency', () => {
+    const nodes = DEFAULT_GITHUB_CDN_NODES.slice(0, 3);
+    const results = new Map<string, LatencyResult>([
+      [nodes[0]!.id, { nodeId: nodes[0]!.id, latency: 300, success: true, timestamp: 1 }],
+      [nodes[1]!.id, { nodeId: nodes[1]!.id, latency: 100, success: true, timestamp: 1 }],
+      [nodes[2]!.id, { nodeId: nodes[2]!.id, latency: 200, success: true, timestamp: 1 }],
+    ]);
+
+    const sorted = getSortedNodesWithLatency(nodes, results);
+    expect(sorted[0]!.latency).toBe(100);
+    expect(sorted[1]!.latency).toBe(200);
+    expect(sorted[2]!.latency).toBe(300);
+  });
+
+  test('failed nodes sort to the end', () => {
+    const nodes = DEFAULT_GITHUB_CDN_NODES.slice(0, 2);
+    const results = new Map<string, LatencyResult>([
+      [nodes[0]!.id, { nodeId: nodes[0]!.id, latency: -1, success: false, timestamp: 1 }],
+      [nodes[1]!.id, { nodeId: nodes[1]!.id, latency: 100, success: true, timestamp: 1 }],
+    ]);
+
+    const sorted = getSortedNodesWithLatency(nodes, results);
+    expect(sorted[0]!.latency).toBe(100);
+    expect(sorted[1]!.latency).toBe(-1);
+  });
+});
+
+describe('createForgeConfig', () => {
+  test('creates config with defaults', () => {
+    const config = createForgeConfig({ user: 'u', repo: 'r', ref: 'main' });
+    expect(config.github.user).toBe('u');
+    expect(config.github.repo).toBe('r');
+    expect(config.github.ref).toBe('main');
+  });
+
+  test('normalizeConfig fills defaults', () => {
+    const config = createForgeConfig({ user: 'u', repo: 'r', ref: 'v1' });
+    const full = normalizeConfig(config);
+    expect(full.splitThreshold).toBe(20 * 1024 * 1024);
+    expect(full.maxConcurrency).toBe(6);
+    expect(full.turboMode).toBe(false);
+    expect(full.nodes).toHaveLength(6);
+  });
+});

package/src/core/__tests__/manifest.test.ts

@@ -0,0 +1,117 @@
+import {
+  parseInfoYaml,
+  serializeInfoYaml,
+  parseCacheYaml,
+  serializeCacheYaml,
+} from '../manifest';
+import type { SplitInfo, SplitCache } from '../../types';
+
+describe('parseInfoYaml', () => {
+  test('parses complete info.yaml', () => {
+    const yaml = `originalName: loli.ass
+totalSize: 26214400
+mimeType: text/x-ssa
+chunkSize: 19922944
+createdAt: "2026-03-29T12:00:00Z"
+chunks:
+  - fileName: 0-loli.ass
+    index: 0
+    size: 19922944
+    sha256: abc123def456
+  - fileName: 1-loli.ass
+    index: 1
+    size: 6291456
+    sha256: 789ghi012jkl
+`;
+
+    const info = parseInfoYaml(yaml);
+
+    expect(info.originalName).toBe('loli.ass');
+    expect(info.totalSize).toBe(26214400);
+    expect(info.mimeType).toBe('text/x-ssa');
+    expect(info.chunkSize).toBe(19922944);
+    expect(info.createdAt).toBe('2026-03-29T12:00:00Z');
+    expect(info.chunks).toHaveLength(2);
+    expect(info.chunks[0]!.fileName).toBe('0-loli.ass');
+    expect(info.chunks[0]!.index).toBe(0);
+    expect(info.chunks[0]!.size).toBe(19922944);
+    expect(info.chunks[0]!.sha256).toBe('abc123def456');
+    expect(info.chunks[1]!.fileName).toBe('1-loli.ass');
+    expect(info.chunks[1]!.size).toBe(6291456);
+  });
+
+  test('handles single chunk', () => {
+    const yaml = `originalName: small.bin
+totalSize: 1000
+mimeType: application/octet-stream
+chunkSize: 1000
+createdAt: "2026-01-01T00:00:00Z"
+chunks:
+  - fileName: 0-small.bin
+    index: 0
+    size: 1000
+    sha256: aaa111
+`;
+    const info = parseInfoYaml(yaml);
+    expect(info.chunks).toHaveLength(1);
+    expect(info.chunks[0]!.sha256).toBe('aaa111');
+  });
+});
+
+describe('serializeInfoYaml', () => {
+  test('round-trips correctly', () => {
+    const info: SplitInfo = {
+      originalName: 'test.bin',
+      totalSize: 50000000,
+      mimeType: 'application/octet-stream',
+      chunkSize: 19922944,
+      createdAt: '2026-03-29T12:00:00Z',
+      chunks: [
+        { fileName: '0-test.bin', index: 0, size: 19922944, sha256: 'hash1' },
+        { fileName: '1-test.bin', index: 1, size: 19922944, sha256: 'hash2' },
+        { fileName: '2-test.bin', index: 2, size: 10154112, sha256: 'hash3' },
+      ],
+    };
+
+    const yaml = serializeInfoYaml(info);
+    const parsed = parseInfoYaml(yaml);
+
+    expect(parsed.originalName).toBe(info.originalName);
+    expect(parsed.totalSize).toBe(info.totalSize);
+    expect(parsed.chunks).toHaveLength(3);
+    expect(parsed.chunks[2]!.sha256).toBe('hash3');
+  });
+});
+
+describe('parseCacheYaml', () => {
+  test('parses .cache.yaml', () => {
+    const yaml = `sourcePath: static/ass/loli.ass
+sourceHash: abcdef1234567890
+sourceSize: 26214400
+generatedAt: "2026-03-29T12:00:00Z"
+`;
+    const cache = parseCacheYaml(yaml);
+    expect(cache.sourcePath).toBe('static/ass/loli.ass');
+    expect(cache.sourceHash).toBe('abcdef1234567890');
+    expect(cache.sourceSize).toBe(26214400);
+    expect(cache.generatedAt).toBe('2026-03-29T12:00:00Z');
+  });
+});
+
+describe('serializeCacheYaml', () => {
+  test('round-trips correctly', () => {
+    const cache: SplitCache = {
+      sourcePath: 'data/big.bin',
+      sourceHash: 'deadbeef',
+      sourceSize: 99999999,
+      generatedAt: '2026-06-01T00:00:00Z',
+    };
+
+    const yaml = serializeCacheYaml(cache);
+    const parsed = parseCacheYaml(yaml);
+
+    expect(parsed.sourcePath).toBe(cache.sourcePath);
+    expect(parsed.sourceHash).toBe(cache.sourceHash);
+    expect(parsed.sourceSize).toBe(cache.sourceSize);
+  });
+});

package/src/core/cdnNodes.ts

@@ -0,0 +1,251 @@
+/**
+ * CDN 节点定义 + 测速工具
+ * 专注 GitHub 文件代理
+ */
+
+import type {
+  CDNNode,
+  CDNNodeWithLatency,
+  GitHubContext,
+  LatencyResult,
+} from '../types';
+
+// ============================================================
+// URL 构建器
+// ============================================================
+
+/** jsDelivr 风格: cdn.jsdelivr.net/gh/{user}/{repo}@{ref}/{path} */
+const buildJsDelivrUrl = (baseUrl: string) =>
+  (ctx: GitHubContext, filePath: string): string => {
+    const path = filePath.startsWith('/') ? filePath : `/${filePath}`;
+    return `${baseUrl}/${ctx.user}/${ctx.repo}@${ctx.ref}${path}`;
+  };
+
+/** GitHub Raw: raw.githubusercontent.com/{user}/{repo}/{ref}/{path} */
+const buildGithubRawUrl = (ctx: GitHubContext, filePath: string): string => {
+  const path = filePath.startsWith('/') ? filePath : `/${filePath}`;
+  return `https://raw.githubusercontent.com/${ctx.user}/${ctx.repo}/${ctx.ref}${path}`;
+};
+
+/** Cloudflare Worker 代理: {domain}/https://raw.githubusercontent.com/... */
+const buildCfWorkerUrl = (domain: string) =>
+  (ctx: GitHubContext, filePath: string): string => {
+    const rawUrl = buildGithubRawUrl(ctx, filePath);
+    return `https://${domain}/${rawUrl}`;
+  };
+
+// ============================================================
+// 预定义节点
+// ============================================================
+
+export const CDN_NODE_PRESETS = {
+  jsdelivr_main: {
+    id: 'jsdelivr-main',
+    name: 'jsDelivr (Main)',
+    baseUrl: 'https://cdn.jsdelivr.net/gh',
+    region: 'global' as const,
+    buildUrl: buildJsDelivrUrl('https://cdn.jsdelivr.net/gh'),
+    maxFileSize: 20 * 1024 * 1024,
+    supportsRange: true,
+    description: 'jsDelivr 主节点，全球 CDN',
+  },
+  jsdelivr_fastly: {
+    id: 'jsdelivr-fastly',
+    name: 'jsDelivr (Fastly)',
+    baseUrl: 'https://fastly.jsdelivr.net/gh',
+    region: 'global' as const,
+    buildUrl: buildJsDelivrUrl('https://fastly.jsdelivr.net/gh'),
+    maxFileSize: 20 * 1024 * 1024,
+    supportsRange: true,
+    description: 'jsDelivr Fastly 节点',
+  },
+  jsdelivr_testing: {
+    id: 'jsdelivr-testing',
+    name: 'jsDelivr (Testing)',
+    baseUrl: 'https://testing.jsdelivr.net/gh',
+    region: 'global' as const,
+    buildUrl: buildJsDelivrUrl('https://testing.jsdelivr.net/gh'),
+    maxFileSize: 20 * 1024 * 1024,
+    supportsRange: true,
+    description: 'jsDelivr 测试节点',
+  },
+  jsd_mirror: {
+    id: 'jsd-mirror',
+    name: 'JSD Mirror',
+    baseUrl: 'https://cdn.jsdmirror.com/gh',
+    region: 'china' as const,
+    buildUrl: buildJsDelivrUrl('https://cdn.jsdmirror.com/gh'),
+    maxFileSize: 20 * 1024 * 1024,
+    supportsRange: true,
+    description: 'jsDelivr 国内镜像，腾讯云 EdgeOne 加速',
+  },
+  zstatic: {
+    id: 'zstatic',
+    name: 'Zstatic',
+    baseUrl: 'https://jsd.zstatic.net/gh',
+    region: 'china' as const,
+    buildUrl: buildJsDelivrUrl('https://jsd.zstatic.net/gh'),
+    maxFileSize: 20 * 1024 * 1024,
+    supportsRange: true,
+    description: 'Zstatic CDN 镜像',
+  },
+  github_raw: {
+    id: 'github-raw',
+    name: 'GitHub Raw',
+    baseUrl: 'https://raw.githubusercontent.com',
+    region: 'global' as const,
+    buildUrl: buildGithubRawUrl,
+    maxFileSize: 100 * 1024 * 1024,
+    supportsRange: true,
+    description: 'GitHub 原始文件服务',
+  },
+} satisfies Record<string, CDNNode>;
+
+/** 默认的 GitHub CDN 节点列表 */
+export const DEFAULT_GITHUB_CDN_NODES: CDNNode[] = [
+  CDN_NODE_PRESETS.jsdelivr_main,
+  CDN_NODE_PRESETS.jsdelivr_fastly,
+  CDN_NODE_PRESETS.jsdelivr_testing,
+  CDN_NODE_PRESETS.jsd_mirror,
+  CDN_NODE_PRESETS.zstatic,
+  CDN_NODE_PRESETS.github_raw,
+];
+
+/**
+ * 创建 Cloudflare Worker 代理节点
+ */
+export function createWorkerNode(domain: string): CDNNode {
+  return {
+    id: `cf-worker-${domain.replace(/\./g, '-')}`,
+    name: `CF Worker (${domain})`,
+    baseUrl: `https://${domain}`,
+    region: 'global',
+    buildUrl: buildCfWorkerUrl(domain),
+    maxFileSize: -1,
+    supportsRange: true,
+    description: `Cloudflare Worker 代理 (${domain})`,
+  };
+}
+
+// ============================================================
+// 测速工具
+// ============================================================
+
+export class CDNTester {
+  private timeout: number;
+  private retryCount: number;
+
+  constructor(timeout = 5000, retryCount = 2) {
+    this.timeout = timeout;
+    this.retryCount = retryCount;
+  }
+
+  /** 测试单节点延迟 */
+  async testNode(node: CDNNode, testUrl?: string): Promise<LatencyResult> {
+    const url = testUrl ?? node.baseUrl;
+
+    for (let attempt = 0; attempt <= this.retryCount; attempt++) {
+      try {
+        const start = performance.now();
+        const ctrl = new AbortController();
+        const tid = setTimeout(() => ctrl.abort(), this.timeout);
+
+        await fetch(url, {
+          method: 'HEAD',
+          mode: 'no-cors',
+          cache: 'no-cache',
+          signal: ctrl.signal,
+        });
+        clearTimeout(tid);
+
+        return {
+          nodeId: node.id,
+          latency: Math.round((performance.now() - start) * 100) / 100,
+          success: true,
+          timestamp: Date.now(),
+        };
+      } catch (err) {
+        if (attempt === this.retryCount) {
+          return {
+            nodeId: node.id,
+            latency: -1,
+            success: false,
+            timestamp: Date.now(),
+            error: err instanceof Error ? err.message : 'Unknown error',
+          };
+        }
+        await delay(200 * (attempt + 1));
+      }
+    }
+
+    return { nodeId: node.id, latency: -1, success: false, timestamp: Date.now() };
+  }
+
+  /** 并发测试所有启用节点 */
+  async testAll(nodes: CDNNode[]): Promise<LatencyResult[]> {
+    const enabled = nodes.filter((n) => n.enabled !== false);
+    return Promise.all(enabled.map((n) => this.testNode(n)));
+  }
+
+  /** 流式测试: 每完成一个就回调 */
+  async testAllStreaming(
+    nodes: CDNNode[],
+    onResult: (r: LatencyResult) => void,
+  ): Promise<LatencyResult[]> {
+    const enabled = nodes.filter((n) => n.enabled !== false);
+    const results: LatencyResult[] = [];
+
+    const promises = enabled.map(async (node) => {
+      const r = await this.testNode(node);
+      results.push(r);
+      onResult(r);
+      return r;
+    });
+
+    await Promise.all(promises);
+    return results;
+  }
+
+  /** 找延迟最低的节点 ID */
+  getBestNodeId(results: LatencyResult[]): string | null {
+    const sorted = results
+      .filter((r) => r.success && r.latency >= 0)
+      .sort((a, b) => a.latency - b.latency);
+    return sorted.length > 0 ? sorted[0]!.nodeId : null;
+  }
+
+  setTimeout(ms: number): void { this.timeout = ms; }
+  setRetryCount(n: number): void { this.retryCount = n; }
+}
+
+/** 获取排序后的节点列表 (带延迟信息) */
+export function getSortedNodesWithLatency(
+  nodes: CDNNode[],
+  results: Map<string, LatencyResult>,
+): CDNNodeWithLatency[] {
+  return nodes
+    .filter((n) => n.enabled !== false)
+    .map((node) => {
+      const r = results.get(node.id);
+      return {
+        ...node,
+        latency: r?.success ? r.latency : r ? -1 : undefined,
+        latencyStatus: r
+          ? r.success ? ('success' as const) : ('failed' as const)
+          : ('idle' as const),
+      };
+    })
+    .sort((a, b) => {
+      if (a.latency === undefined && b.latency === undefined) return 0;
+      if (a.latency === undefined) return 1;
+      if (b.latency === undefined) return -1;
+      if (a.latency < 0 && b.latency < 0) return 0;
+      if (a.latency < 0) return 1;
+      if (b.latency < 0) return -1;
+      return a.latency - b.latency;
+    });
+}
+
+function delay(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}