react-native-update 10.37.13 → 10.37.16

package/scripts/read.js

@@ -0,0 +1,188 @@
+const fs = require('fs');
+
+/**
+ * 从 Hermes 字节码文件中读取 metadata
+ * 支持两种方式：
+ * 1. 从文件末尾的自定义 Meta 块读取（新方式，推荐）
+ * 2. 从 Hermes -meta 参数注入的数据读取（旧方式，备用）
+ */
+function readBundleMetadata(filePath) {
+  const buffer = fs.readFileSync(filePath);
+
+  // 优先尝试从文件末尾的自定义 Meta 块读取
+  const metaFromFooter = readMetadataFromHBCFooter(buffer);
+  if (metaFromFooter) {
+    return metaFromFooter;
+  }
+
+  // 如果末尾没有 Meta 块，尝试从 Hermes -meta 参数注入的数据读取（备用方案）
+  console.log('No metadata footer found, trying to read from Hermes -meta parameter...');
+  return readMetadataFromHermesMeta(buffer);
+}
+
+/**
+ * 从 HBC 文件末尾的自定义 Meta 块读取元数据
+ * 格式: [原始HBC][MAGIC_START][LENGTH][JSON_DATA][MAGIC_END]
+ */
+function readMetadataFromHBCFooter(buffer) {
+  const MAGIC = Buffer.from('RNUPDATE', 'utf8'); // 8 bytes
+  const MAGIC_SIZE = 8;
+  const LENGTH_SIZE = 4;
+
+  console.log(`\n[DEBUG] Reading metadata from HBC footer...`);
+  console.log(`[DEBUG] File size: ${buffer.length} bytes`);
+  console.log(`[DEBUG] Last 100 bytes (hex): ${buffer.slice(-100).toString('hex')}`);
+  console.log(`[DEBUG] Last 50 bytes (utf8): ${buffer.slice(-50).toString('utf8', 0, 50).replace(/[^\x20-\x7E]/g, '.')}`);
+
+  // 检查文件是否足够大以包含 meta 块
+  // 最小大小: MAGIC_START(8) + LENGTH(4) + JSON(至少2字节"{}") + MAGIC_END(8) = 22 bytes
+  if (buffer.length < 22) {
+    console.log(`[DEBUG] File too small: ${buffer.length} < 22`);
+    return null;
+  }
+
+  // 从文件末尾向前查找最后一个 MAGIC_END
+  const lastMagicIndex = buffer.lastIndexOf(MAGIC);
+
+  console.log(`[DEBUG] MAGIC string: "${MAGIC.toString('utf8')}"`);
+  console.log(`[DEBUG] Last MAGIC index: ${lastMagicIndex}`);
+
+  if (lastMagicIndex === -1) {
+    console.log(`[DEBUG] MAGIC not found in file`);
+    return null;
+  }
+
+  // MAGIC_END 应该在文件末尾
+  console.log(`[DEBUG] Expected MAGIC_END at: ${buffer.length - MAGIC_SIZE}`);
+  console.log(`[DEBUG] Found MAGIC_END at: ${lastMagicIndex}`);
+
+  if (lastMagicIndex + MAGIC_SIZE !== buffer.length) {
+    console.warn(`⚠️  Found MAGIC but not at file end (expected ${buffer.length - MAGIC_SIZE}, found ${lastMagicIndex})`);
+    return null;
+  }
+
+  // 计算 MAGIC_START 的位置
+  // 从 MAGIC_END 向前：MAGIC_END(8) + JSON(?) + LENGTH(4) + MAGIC_START(8)
+  const magicEndStart = lastMagicIndex;
+
+  // 读取长度字段（在 MAGIC_END 之前的 4 字节）
+  const lengthStart = magicEndStart - LENGTH_SIZE;
+  if (lengthStart < MAGIC_SIZE) {
+    console.log(`[DEBUG] lengthStart too small: ${lengthStart} < ${MAGIC_SIZE}`);
+    return null; // 文件太小
+  }
+
+  const jsonLength = buffer.readUInt32LE(lengthStart);
+  console.log(`[DEBUG] JSON length from buffer: ${jsonLength}`);
+
+  // 验证长度是否合理（JSON 数据应该小于 10KB）
+  if (jsonLength > 10240 || jsonLength < 2) {
+    console.warn(`⚠️  Invalid JSON length: ${jsonLength}`);
+    return null;
+  }
+
+  // 计算 JSON 数据的起始位置
+  const jsonStart = lengthStart - jsonLength;
+  console.log(`[DEBUG] JSON start position: ${jsonStart}`);
+  if (jsonStart < MAGIC_SIZE) {
+    console.log(`[DEBUG] jsonStart too small: ${jsonStart} < ${MAGIC_SIZE}`);
+    return null;
+  }
+
+  // 验证 MAGIC_START
+  const magicStartPos = jsonStart - MAGIC_SIZE;
+  console.log(`[DEBUG] MAGIC_START position: ${magicStartPos}`);
+  const magicStart = buffer.slice(magicStartPos, jsonStart);
+  console.log(`[DEBUG] MAGIC_START bytes: ${magicStart.toString('hex')}`);
+  console.log(`[DEBUG] Expected MAGIC bytes: ${MAGIC.toString('hex')}`);
+
+  if (!magicStart.equals(MAGIC)) {
+    console.warn('⚠️  MAGIC_START mismatch');
+    console.warn(`    Expected: ${MAGIC.toString('hex')}`);
+    console.warn(`    Got: ${magicStart.toString('hex')}`);
+    return null;
+  }
+
+  // 读取 JSON 数据
+  try {
+    const jsonBuffer = buffer.slice(jsonStart, lengthStart);
+    const jsonString = jsonBuffer.toString('utf8');
+    console.log(`[DEBUG] JSON string: ${jsonString}`);
+    const metadata = JSON.parse(jsonString);
+
+    console.log(`✅ Found metadata in HBC footer: contentHash=${metadata.contentHash?.slice(0, 16)}...`);
+    console.log(`   Metadata: ${JSON.stringify(metadata, null, 2)}`);
+
+    return metadata;
+  } catch (error) {
+    console.error('❌ Failed to parse metadata JSON:', error);
+    return null;
+  }
+}
+
+/**
+ * 从 Hermes -meta 参数注入的数据读取（备用方案）
+ */
+function readMetadataFromHermesMeta(buffer) {
+  const metadata = {};
+  const searchPattern = Buffer.from('contentHash=', 'utf8');
+
+  // 在整个文件中查找模式
+  let index = buffer.indexOf(searchPattern);
+
+  if (index !== -1) {
+    // 找到了 "contentHash="，读取后面的 hash 值
+    const hashStart = index + searchPattern.length;
+
+    // Hash 应该是 64 个十六进制字符 (SHA256)
+    let hashEnd = hashStart;
+    while (hashEnd < buffer.length && hashEnd < hashStart + 64) {
+      const byte = buffer[hashEnd];
+      // 检查是否是有效的十六进制字符 (0-9, a-f, A-F)
+      if ((byte >= 48 && byte <= 57) ||   // 0-9
+          (byte >= 97 && byte <= 102) ||  // a-f
+          (byte >= 65 && byte <= 70)) {   // A-F
+        hashEnd++;
+      } else {
+        break;
+      }
+    }
+
+    if (hashEnd > hashStart) {
+      metadata.contentHash = buffer.toString('utf8', hashStart, hashEnd);
+      console.log(`✅ Found contentHash in Hermes -meta: ${metadata.contentHash.slice(0, 16)}...`);
+    }
+  } else {
+    console.warn('⚠️  contentHash not found in Hermes -meta parameter');
+  }
+
+  return metadata;
+}
+
+/**
+ * 从普通 JS bundle 的注释中读取 metadata
+ */
+function readMetadataFromJSBundle(buffer) {
+  const content = buffer.toString('utf8');
+  const metadata = {};
+
+  // 查找 //# BUNDLE_METADATA {...} 注释
+  const metaMatch = content.match(/\/\/# BUNDLE_METADATA\s+(\{[^}]+\})/);
+  if (metaMatch) {
+    try {
+      const metaObj = JSON.parse(metaMatch[1]);
+      metadata.contentHash = metaObj.contentHash;
+      console.log(`✅ Found contentHash in JS bundle comment: ${metadata.contentHash.slice(0, 16)}...`);
+    } catch (e) {
+      console.error('Failed to parse BUNDLE_METADATA comment:', e);
+    }
+  } else {
+    console.warn('⚠️  BUNDLE_METADATA comment not found in JS bundle');
+  }
+
+  return metadata;
+}
+
+// 测试读取
+const metadata = readBundleMetadata('./index.bundlejs');
+console.log('Final metadata:', metadata);

package/src/__tests__/core.test.ts

@@ -0,0 +1,103 @@
+import { describe, expect, test, mock } from 'bun:test';
+
+// In Bun, top-level imports are cached.
+// We can use mock.module to change the implementation of a module,
+// but if a module has already been executed (like core.ts),
+// re-importing it might not re-run the top-level code unless we use some tricks
+// or run tests in isolation.
+// Actually, bun test runs each file in its own environment usually,
+// BUT if we run multiple test files in one process, they might share the cache.
+const importFreshCore = (cacheKey: string) => import(`../core?${cacheKey}`);
+
+describe('core info parsing', () => {
+  test('should call error when currentVersionInfo is invalid JSON', async () => {
+    const mockError = mock(() => {});
+
+    mock.module('react-native', () => ({
+      Platform: {
+        OS: 'ios',
+        Version: 13,
+      },
+      NativeModules: {
+        Pushy: {
+          currentVersionInfo: '{invalid}',
+          downloadRootDir: '/tmp',
+          packageVersion: '1.0.0',
+          currentVersion: 'hash1',
+          isFirstTime: false,
+          rolledBackVersion: '',
+          buildTime: '2023-01-01',
+          uuid: 'existing-uuid',
+          setLocalHashInfo: mock(() => {}),
+          getLocalHashInfo: mock(() => Promise.resolve('{}')),
+          setUuid: mock(() => {}),
+        },
+      },
+      NativeEventEmitter: class {
+        addListener = mock(() => ({ remove: mock(() => {}) }));
+      },
+    }));
+
+    mock.module('react-native/Libraries/Core/ReactNativeVersion', () => ({
+      version: { major: 0, minor: 73, patch: 0 },
+    }));
+
+    mock.module('nanoid/non-secure', () => ({
+      nanoid: () => 'mock-uuid',
+    }));
+
+    mock.module('../utils', () => ({
+      error: mockError,
+      log: mock(() => {}),
+      emptyModule: {},
+    }));
+
+    // Use a unique query parameter to bypass cache if supported, or just rely on fresh environment per file.
+    // In Bun, you can sometimes use a cache buster if it's dynamic import.
+    await importFreshCore('error');
+
+    expect(mockError).toHaveBeenCalledWith(
+      expect.stringContaining('error_parse_version_info')
+    );
+  });
+
+  test('should not call error when currentVersionInfo is valid JSON', async () => {
+    const mockError = mock(() => {});
+    const mockSetLocalHashInfo = mock(() => {});
+
+    mock.module('react-native', () => ({
+      Platform: {
+        OS: 'ios',
+        Version: 13,
+      },
+      NativeModules: {
+        Pushy: {
+          currentVersionInfo: JSON.stringify({ name: 'v1', debugChannel: true }),
+          downloadRootDir: '/tmp',
+          packageVersion: '1.0.0',
+          currentVersion: 'hash1',
+          isFirstTime: false,
+          rolledBackVersion: '',
+          buildTime: '2023-01-01',
+          uuid: 'existing-uuid',
+          setLocalHashInfo: mockSetLocalHashInfo,
+          getLocalHashInfo: mock(() => Promise.resolve('{}')),
+          setUuid: mock(() => {}),
+        },
+      },
+      NativeEventEmitter: class {
+        addListener = mock(() => ({ remove: mock(() => {}) }));
+      },
+    }));
+
+    mock.module('../utils', () => ({
+      error: mockError,
+      log: mock(() => {}),
+      emptyModule: {},
+    }));
+
+    await importFreshCore('success');
+
+    expect(mockError).not.toHaveBeenCalled();
+  });
+});

package/src/__tests__/setup.ts

@@ -0,0 +1,37 @@
+import { mock } from 'bun:test';
+
+mock.module('react-native', () => {
+  return {
+    Platform: {
+      OS: 'ios',
+      Version: 13,
+    },
+    NativeModules: {
+      Pushy: {
+        currentVersionInfo: '{}',
+        downloadRootDir: '/tmp',
+        packageVersion: '1.0.0',
+        currentVersion: 'hash',
+        isFirstTime: false,
+        rolledBackVersion: '',
+        buildTime: '2023-01-01',
+        uuid: 'uuid',
+        setLocalHashInfo: () => {},
+        getLocalHashInfo: () => Promise.resolve('{}'),
+        setUuid: () => {},
+      },
+    },
+    NativeEventEmitter: class {
+      addListener = () => ({ remove: () => {} });
+      removeAllListeners = () => {};
+    },
+  };
+});
+
+mock.module('../i18n', () => {
+  return {
+    default: {
+      t: (key: string, params?: any) => `${key}${params ? JSON.stringify(params) : ''}`,
+    },
+  };
+});

package/src/__tests__/utils.test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, test, mock } from 'bun:test';
+
+mock.module('react-native', () => {
+  return {
+    Platform: {
+      OS: 'ios',
+    },
+  };
+});
+
+mock.module('../i18n', () => {
+  return {
+    default: {
+      t: (key: string) => key,
+    },
+  };
+});
+
+import { joinUrls } from '../utils';
+
+describe('joinUrls', () => {
+  test('returns undefined when fileName is not provided', () => {
+    expect(joinUrls(['example.com'])).toBeUndefined();
+  });
+
+  test('returns an empty array when paths is empty', () => {
+    expect(joinUrls([], 'file.txt')).toEqual([]);
+  });
+
+  test('maps over paths and prepends https:// with fileName', () => {
+    expect(joinUrls(['example.com', 'test.org'], 'file.txt')).toEqual([
+      'https://example.com/file.txt',
+      'https://test.org/file.txt',
+    ]);
+  });
+});

package/src/client.ts

@@ -22,6 +22,7 @@ import {
   assertWeb,
   emptyObj,
   enhancedFetch,
+  info,
   joinUrls,
   log,
   noop,
@@ -189,7 +190,7 @@ export class Pushy {
   };
   assertDebug = (matter: string) => {
     if (__DEV__ && !this.options.debug) {
-      console.info(this.t('dev_debug_disabled', { matter }));
+      info(this.t('dev_debug_disabled', { matter }));
       return false;
     }
     return true;
@@ -323,9 +324,10 @@ export class Pushy {
       this.throwIfEnabled(Error('errorChecking: ' + errorMessage));
       return this.lastRespJson ? await this.lastRespJson : emptyObj;
     }
-    this.lastRespJson = resp.json();
+    const respJsonPromise = resp.json() as Promise<CheckResult>;
+    this.lastRespJson = respJsonPromise;
 
-    const result: CheckResult = await this.lastRespJson;
+    const result: CheckResult = await respJsonPromise;
 
     log('checking result:', result);
 
@@ -344,9 +346,14 @@ export class Pushy {
         const remoteEndpoints = await resp.json();
         log('fetch endpoints:', remoteEndpoints);
         if (Array.isArray(remoteEndpoints)) {
-          server.backups = Array.from(
-            new Set([...(server.backups || []), ...remoteEndpoints]),
-          );
+          const backups = server.backups || [];
+          const set = new Set(backups);
+          for (const endpoint of remoteEndpoints) {
+            set.add(endpoint);
+          }
+          if (set.size !== backups.length) {
+            server.backups = Array.from(set);
+          }
         }
       } catch (e: any) {
         log('failed to fetch endpoints from: ', server.queryUrls);
@@ -355,7 +362,7 @@ export class Pushy {
     return server.backups;
   };
   downloadUpdate = async (
-    info: CheckResult,
+    updateInfo: CheckResult,
     onDownloadProgress?: (data: ProgressData) => void,
   ) => {
     const {
@@ -367,15 +374,15 @@ export class Pushy {
       name,
       description = '',
       metaInfo,
-    } = info;
+    } = updateInfo;
     if (
       this.options.beforeDownloadUpdate &&
-      (await this.options.beforeDownloadUpdate(info)) === false
+      (await this.options.beforeDownloadUpdate(updateInfo)) === false
     ) {
       log('beforeDownloadUpdate returned false, skipping download');
       return;
     }
-    if (!info.update || !hash) {
+    if (!updateInfo.update || !hash) {
       return;
     }
     if (rolledBackVersion === hash) {

package/src/core.ts

@@ -1,5 +1,6 @@
 import { NativeEventEmitter, NativeModules, Platform } from 'react-native';
-import { emptyModule, log } from './utils';
+import { emptyModule, error, log } from './utils';
+import i18n from './i18n';
 const {
   version: v,
 } = require('react-native/Libraries/Core/ReactNativeVersion');
@@ -46,10 +47,9 @@ if (currentVersionInfoString) {
       delete _currentVersionInfo.debugChannel;
       setLocalHashInfo(currentVersion, _currentVersionInfo);
     }
-  } catch (error) {
-    console.error(
-      'Failed to parse currentVersionInfo:',
-      currentVersionInfoString,
+  } catch (err) {
+    error(
+      i18n.t('error_parse_version_info', { info: currentVersionInfoString }),
     );
   }
 }

package/src/locales/en.ts

@@ -44,6 +44,7 @@ export default {
 
   // Error messages
   error_appkey_required: 'appKey is required',
+  error_parse_version_info: 'Failed to parse currentVersionInfo: {{info}}',
   error_update_check_failed: 'Update check failed',
   error_cannot_connect_server:
     'Can not connect to update server. Please check your network.',

package/src/locales/zh.ts

@@ -42,6 +42,7 @@ export default {
 
   // Error messages
   error_appkey_required: '需要提供 appKey',
+  error_parse_version_info: '解析 currentVersionInfo 失败: {{info}}',
   error_update_check_failed: '更新检查失败',
   error_cannot_connect_server: '无法连接到更新服务器。请检查网络连接。',
   error_cannot_connect_backup:

package/src/utils.ts

@@ -5,6 +5,18 @@ export function log(...args: any[]) {
   console.log(i18n.t('dev_log_prefix'), ...args);
 }
 
+export function info(...args: any[]) {
+  console.info(i18n.t('dev_log_prefix'), ...args);
+}
+
+export function warn(...args: any[]) {
+  console.warn(i18n.t('dev_log_prefix'), ...args);
+}
+
+export function error(...args: any[]) {
+  console.error(i18n.t('dev_log_prefix'), ...args);
+}
+
 export const isWeb = Platform.OS === 'web';
 
 export function promiseAny<T>(promises: Promise<T>[]) {
@@ -93,7 +105,7 @@ export const testUrls = async (urls?: string[]) => {
 
 export const assertWeb = () => {
   if (isWeb) {
-    console.warn(i18n.t('dev_web_not_supported'));
+    warn(i18n.t('dev_web_not_supported'));
     return false;
   }
   return true;