Обновление по воздуху — это HTTP-ответ

// app.config.js приложения автора, секция обновлений; сокращено
updates: {
  url: `https://u.expo.dev/${EAS_PROJECT_ID}`,
  // ждать обновление не дольше 8 с, иначе стартуем со старой версии
  fallbackToCacheTimeout: 8000,
  checkAutomatically: "ON_LOAD",
},
runtimeVersion: { policy: "appVersion" },

GET https://u.expo.dev/<projectId>
Expo-Current-Update-ID: <id обновления, на котором приложение запущено>
Expo-Embedded-Update-ID: <id обновления, вшитого в сборку>
Accept: multipart/mixed,application/expo+json,application/json
Expo-Platform: android
Expo-Protocol-Version: 1
Expo-API-Version: 1
Expo-Updates-Environment: BARE
Expo-JSON-Error: true
EAS-Client-ID: <UUID этой установки>
Expo-Runtime-Version: 1.0.0
expo-channel-name: production

HTTP/1.1 200 OK
expo-protocol-version: 1
content-type: multipart/mixed; boundary=podhod-7f3a9c

--podhod-7f3a9c
content-disposition: form-data; name="manifest"
content-type: application/json

{
  "id": "0199377e-5c1a-7b3e-9f4d-2a6c1e8b0d45",
  "createdAt": "2026-09-11T08:30:00.000Z",
  "runtimeVersion": "1.0.0",
  "launchAsset": {
    "hash": "aFng-kP8qaHptGXf7TsIFVu2GCdrCEvtuFWl0Q6RBA0",
    "key": "0fc8ccd9d0f4d9852002e22fc5d18159",
    "contentType": "application/javascript",
    "url": "https://updates.podhod.example/assets/0fc8ccd9d0f4d9852002e22fc5d18159"
  },
  "assets": [
    {
      "hash": "Pdik49SwYTLLQfkhc_UCvz99xOooBPQAo0iImlWURnU",
      "key": "719031eee7a5bfe63e25f22f864c30e4",
      "contentType": "image/png",
      "fileExtension": ".png",
      "url": "https://updates.podhod.example/assets/719031eee7a5bfe63e25f22f864c30e4"
    },
    {
      "hash": "1aucMqevg4ReVQsFn3OsBrTEC6B3w6USEdV1eYcPhPE",
      "key": "f5ad6349009f26e5a772a5be9603e829",
      "contentType": "font/ttf",
      "fileExtension": ".ttf",
      "url": "https://updates.podhod.example/assets/f5ad6349009f26e5a772a5be9603e829"
    },
    {
      "hash": "KeUGQwHSepvk7OJbldZZZp4nzs8JIHFe-Ne0_1u6Lzg",
      "key": "5bef82d899ec67ac491d055226070594",
      "contentType": "image/png",
      "fileExtension": ".png",
      "url": "https://updates.podhod.example/assets/5bef82d899ec67ac491d055226070594"
    }
  ],
  "metadata": {},
  "extra": {
    "expoClient": {
      "name": "Подход",
      "version": "1.0.0"
    }
  }
}
--podhod-7f3a9c
content-disposition: form-data; name="extensions"
content-type: application/json

{"assetRequestHeaders":{}}
--podhod-7f3a9c--

// сервер обновлений в миниатюре лежит в подложке: принимает Request, отдаёт Response
declare function updateServer(request: Request): Promise<Response>;

type Part = { headers: Record<string, string>; body: string };

function parseMultipart(contentType: string, text: string): Part[] {
  const boundary = /boundary="?([^";]+)"?/.exec(contentType)?.[1];
  if (boundary === undefined) throw new Error("в content-type нет boundary");
  const parts: Part[] = [];
  // кусок до первой границы — преамбула, после «--граница--» — эпилог
  for (const chunk of text.split("--" + boundary).slice(1)) {
    if (chunk.startsWith("--")) break;
    // заголовки части отделены от её тела пустой строкой — как у всего ответа
    const blank = chunk.indexOf("\r\n\r\n");
    const headers: Record<string, string> = {};
    for (const line of chunk.slice(2, blank).split("\r\n")) {
      const colon = line.indexOf(":");
      headers[line.slice(0, colon).toLowerCase()] = line.slice(colon + 1).trim();
    }
    parts.push({ headers, body: chunk.slice(blank + 4, -2) });
  }
  return parts;
}

async function check(): Promise<void> {
  const request = new Request("https://updates.podhod.example/manifest", {
    headers: { "expo-platform": "android", "expo-protocol-version": "1", "expo-runtime-version": "1.0.0" },
  });
  const res = await updateServer(request);
  const contentType = res.headers.get("content-type") ?? "";
  console.log(res.status, contentType);
  const text = await res.clone().text();
  console.log("res.json():", await res.json().catch((err: Error) => err.name));
  for (const part of parseMultipart(contentType, text)) {
    console.log(part.headers["content-disposition"], "→", part.body.slice(0, 24) + "…");
  }
}

check();

type Part = { headers: Record<string, string>; body: string };
declare function updateServer(request: Request): Promise<Response>;
declare function parseMultipart(contentType: string, text: string): Part[];

// поля — как в типе ExpoUpdatesManifest из пакета expo-manifests
interface ManifestAsset {
  key: string;
  url: string;
  hash?: string;
  contentType: string;
  fileExtension?: string;
}
interface Manifest {
  id: string;
  createdAt: string;
  runtimeVersion: string;
  launchAsset: ManifestAsset;
  assets: ManifestAsset[];
  metadata: object;
}

// часть ищется по имени из content-disposition, а не по месту в ответе
function partNamed(parts: Part[], name: string): Part | undefined {
  return parts.find((p) => p.headers["content-disposition"]?.includes(`name="${name}"`));
}

async function readManifest(res: Response): Promise<Manifest | null> {
  const parts = parseMultipart(res.headers.get("content-type") ?? "", await res.text());
  const part = partNamed(parts, "manifest");
  return part ? JSON.parse(part.body) : null;
}

async function show(): Promise<void> {
  const m = await readManifest(await updateServer(new Request("https://updates.podhod.example/manifest")));
  if (!m) return;
  console.log("обновление", m.id, "для runtimeVersion", m.runtimeVersion);
  console.log("бандл:", m.launchAsset.contentType, m.launchAsset.url);
  for (const a of m.assets) console.log("ассет:", a.key + a.fileExtension, a.contentType);
}

show();

interface ManifestAsset { key: string; url: string; hash?: string; contentType: string; fileExtension?: string }
interface Manifest { id: string; launchAsset: ManifestAsset; assets: ManifestAsset[] }
declare function updateServer(request: Request): Promise<Response>;
declare function readManifest(res: Response): Promise<Manifest | null>;
// ключи файлов, которые уже лежат на телефоне: всё, что вшито в сборку из магазина
declare const embeddedKeys: string[];

function planDownloads(m: Manifest, onPhone: Set<string>): ManifestAsset[] {
  const all = [m.launchAsset, ...m.assets];
  // один ключ — один файл, даже если манифест назвал его дважды
  const unique = all.filter((a, i) => all.findIndex((b) => b.key === a.key) === i);
  return unique.filter((a) => !onPhone.has(a.key));
}

async function plan(): Promise<void> {
  const m = await readManifest(await updateServer(new Request("https://updates.podhod.example/manifest")));
  if (!m) return;
  const toDownload = planDownloads(m, new Set(embeddedKeys));
  console.log("файлов в манифесте:", m.assets.length + 1);
  for (const a of toDownload) console.log("скачать:", a.contentType, a.key.slice(0, 8));
  console.log("уже на телефоне:", m.assets.length + 1 - toDownload.length);
}

plan();

interface ManifestAsset { key: string; url: string; hash?: string; contentType: string }
interface Manifest { id: string; launchAsset: ManifestAsset; assets: ManifestAsset[] }
declare function updateServer(request: Request): Promise<Response>;
declare function readManifest(res: Response): Promise<Manifest | null>;
declare function planDownloads(m: Manifest, onPhone: Set<string>): ManifestAsset[];
declare const embeddedKeys: string[];
// раздача файлов по адресу из манифеста; первая отдача картинки обрывается на середине
declare function download(url: string): Promise<Response>;
// SHA-256 в base64url; на телефоне его считает нативный код, пока пишет файл
declare function sha256(text: string): Promise<string>;

async function fetchAsset(a: ManifestAsset): Promise<[string, string]> {
  const body = await (await download(a.url)).text();
  const actual = await sha256(body);
  if (a.hash !== undefined && actual !== a.hash) {
    throw new Error(`hash не совпал у ${a.key.slice(0, 8)}: пришло ${body.length} символов`);
  }
  return [a.key, body];
}

let running = "сборка из магазина";

async function tryUpdate(attempt: number): Promise<void> {
  const m = await readManifest(await updateServer(new Request("https://updates.podhod.example/manifest")));
  if (!m) return;
  try {
    // все файлы разом: в Loader.kt загрузки тоже идут параллельно
    const saved = await Promise.all(planDownloads(m, new Set(embeddedKeys)).map(fetchAsset));
    running = "обновление " + m.id.slice(0, 8);
    console.log(`попытка ${attempt}: проверено файлов ${saved.length}, дальше запускается ${running}`);
  } catch (err) {
    console.log(`попытка ${attempt}: ${(err as Error).message}`);
    console.log(`  приложение остаётся на прежнем: ${running}`);
  }
}

tryUpdate(1).then(() => tryUpdate(2));

type Part = { headers: Record<string, string>; body: string };
declare function parseMultipart(contentType: string, text: string): Part[];
declare function partNamed(parts: Part[], name: string): Part | undefined;
declare function updateServer(request: Request): Promise<Response>;
declare function multipartResponse(parts: { name: string; body: unknown }[]): Response;

// форма — как у результата Updates.checkForUpdateAsync(), только вместо манифеста его id
type CheckResult =
  | { isAvailable: true; manifestId: string; isRollBackToEmbedded: false }
  | { isAvailable: false; isRollBackToEmbedded: true }
  | { isAvailable: false; isRollBackToEmbedded: false; reason: "noUpdateAvailableOnServer" };

const none: CheckResult = { isAvailable: false, isRollBackToEmbedded: false, reason: "noUpdateAvailableOnServer" };

async function toCheckResult(res: Response): Promise<CheckResult> {
  if (res.status === 204) {
    // у 204 нет тела: решать можно только по статусу и заголовкам
    if (Number(res.headers.get("expo-protocol-version")) > 0) return none;
    throw new Error("Invalid update response: пустое тело");
  }
  const parts = parseMultipart(res.headers.get("content-type") ?? "", await res.text());
  const manifest = partNamed(parts, "manifest");
  if (manifest) return { isAvailable: true, manifestId: JSON.parse(manifest.body).id, isRollBackToEmbedded: false };
  const directive = partNamed(parts, "directive");
  if (directive && JSON.parse(directive.body).type === "rollBackToEmbedded") {
    return { isAvailable: false, isRollBackToEmbedded: true };
  }
  return none;
}

const rollBack = { type: "rollBackToEmbedded", parameters: { commitTime: "2026-09-01T10:00:00.000Z" } };
const answersList: [string, () => Promise<Response>][] = [
  ["манифест", () => updateServer(new Request("https://updates.podhod.example/manifest"))],
  ["директива", async () => multipartResponse([{ name: "directive", body: rollBack }])],
  ["204", async () => new Response(null, { status: 204, headers: { "expo-protocol-version": "1" } })],
  ["204 без версии", async () => new Response(null, { status: 204 })],
];
(async () => {
  for (const [label, answer] of answersList) {
    await answer().then(toCheckResult).then(
      (result) => console.log(label + ":", result),
      (err: Error) => console.log(label + ":", err.message),
    );
  }
})();

// так проверяют обновление из JS — например, по кнопке в настройках
import * as Updates from "expo-updates";

export async function updateNow(): Promise<void> {
  const check = await Updates.checkForUpdateAsync();
  if (!check.isAvailable) return;
  // скачать бандл и ассеты, сверить hash, записать в базу expo-updates
  await Updates.fetchUpdateAsync();
  // без этого скачанное запустится только при следующем холодном старте
  await Updates.reloadAsync();
}