@absolutejs/absolute 0.20.0-beta.6 → 0.20.0-beta.61

package/dist/mobile/shellUpdate.js

@@ -0,0 +1,532 @@
+// src/mobile/shellUpdate.ts
+import { Directory, Filesystem } from "@capacitor/filesystem";
+import { Preferences } from "@capacitor/preferences";
+import { registerPlugin } from "@capacitor/core";
+
+// src/mobile/updateProtocol.ts
+var ABSOLUTE_MOBILE_UPDATE_FORMAT = 1;
+var ABSOLUTE_MOBILE_UPDATE_MAX_FILE_BYTES = 32 * 1024 * 1024;
+var ABSOLUTE_MOBILE_UPDATE_MAX_FILES = 1e4;
+var ABSOLUTE_MOBILE_UPDATE_MAX_TOTAL_BYTES = 128 * 1024 * 1024;
+var ABSOLUTE_MOBILE_UPDATE_SIGNATURE_ALGORITHM = "ecdsa-p256-sha256";
+var HASH_PATTERN = /^[a-f0-9]{64}$/u;
+var RELEASE_PATTERN = /^amu_[a-f0-9]{64}$/u;
+var KEY_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/u;
+var CHANNEL_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/u;
+var isClassification = (value) => value === "bug-fix" || value === "content" || value === "security";
+var object = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var canonicalValue = (value) => {
+  if (Array.isArray(value))
+    return value.map(canonicalValue);
+  if (!object(value))
+    return value;
+  return Object.fromEntries(Object.keys(value).sort().map((key) => [key, canonicalValue(value[key])]));
+};
+var absoluteMobileUpdateSigningPayload = (manifest) => new TextEncoder().encode(canonicalizeAbsoluteMobileUpdate(manifest));
+var canonicalizeAbsoluteMobileUpdate = (value) => JSON.stringify(canonicalValue(value));
+var requireText = (value, field) => {
+  if (typeof value !== "string" || value.length === 0)
+    throw new TypeError(`${field} must be a non-empty string.`);
+  return value;
+};
+var normalizeAbsoluteMobileUpdatePath = (value) => {
+  const path = requireText(value, "Update file path").replaceAll("\\", "/");
+  if (path.startsWith("/") || path.includes("\x00") || path.split("/").some((segment) => !segment || segment === "." || segment === "..")) {
+    throw new TypeError("Update file paths must be normalized relative paths.");
+  }
+  return path;
+};
+var parseFile = (value) => {
+  if (!object(value))
+    throw new TypeError("Update files must be objects.");
+  const path = normalizeAbsoluteMobileUpdatePath(value.path);
+  if (typeof value.bytes !== "number" || !Number.isSafeInteger(value.bytes) || value.bytes < 0 || value.bytes > ABSOLUTE_MOBILE_UPDATE_MAX_FILE_BYTES) {
+    throw new TypeError(`Update file ${path} has an invalid byte length.`);
+  }
+  if (typeof value.sha256 !== "string" || !HASH_PATTERN.test(value.sha256))
+    throw new TypeError(`Update file ${path} has an invalid SHA-256 digest.`);
+  return { bytes: value.bytes, path, sha256: value.sha256 };
+};
+var parseAbsoluteMobileUnsignedUpdateManifest = (value) => {
+  if (!object(value) || value.format !== ABSOLUTE_MOBILE_UPDATE_FORMAT)
+    throw new TypeError("Invalid AbsoluteJS mobile update manifest.");
+  const appId = requireText(value.appId, "Update appId");
+  const channel = requireText(value.channel, "Update channel");
+  if (!CHANNEL_PATTERN.test(channel))
+    throw new TypeError("Update channel contains unsupported characters.");
+  if (!isClassification(value.classification))
+    throw new TypeError("Update classification is invalid.");
+  const createdAt = requireText(value.createdAt, "Update createdAt");
+  if (!Number.isFinite(Date.parse(createdAt)) || new Date(createdAt).toISOString() !== createdAt)
+    throw new TypeError("Update createdAt must be a canonical ISO timestamp.");
+  if (!Array.isArray(value.files) || value.files.length === 0)
+    throw new TypeError("An update must contain at least one file.");
+  if (value.files.length > ABSOLUTE_MOBILE_UPDATE_MAX_FILES)
+    throw new TypeError("Update contains too many files.");
+  const files = value.files.map(parseFile);
+  const sorted = [...files].sort((left, right) => left.path.localeCompare(right.path));
+  if (files.some((file, index) => file.path !== sorted[index]?.path))
+    throw new TypeError("Update files must be sorted by path.");
+  if (new Set(files.map(({ path }) => path)).size !== files.length)
+    throw new TypeError("Update file paths must be unique.");
+  if (files.reduce((total, file) => total + file.bytes, 0) > ABSOLUTE_MOBILE_UPDATE_MAX_TOTAL_BYTES)
+    throw new TypeError("Update exceeds the maximum uncompressed size.");
+  if (typeof value.releaseId !== "string" || !RELEASE_PATTERN.test(value.releaseId))
+    throw new TypeError("Update releaseId is invalid.");
+  if (typeof value.runtimeFingerprint !== "string" || !HASH_PATTERN.test(value.runtimeFingerprint))
+    throw new TypeError("Update runtime fingerprint is invalid.");
+  if (value.withinSubmittedPurpose !== true)
+    throw new TypeError("OTA updates must attest that they remain within the submitted app purpose.");
+  return {
+    appId,
+    channel,
+    classification: value.classification,
+    createdAt,
+    files,
+    format: ABSOLUTE_MOBILE_UPDATE_FORMAT,
+    releaseId: value.releaseId,
+    runtimeFingerprint: value.runtimeFingerprint,
+    withinSubmittedPurpose: true
+  };
+};
+var parseAbsoluteMobileUpdateManifest = (value) => {
+  if (!object(value))
+    throw new TypeError("Invalid AbsoluteJS mobile update manifest.");
+  const { signature: signatureValue, ...unsignedValue } = value;
+  const unsigned = parseAbsoluteMobileUnsignedUpdateManifest(unsignedValue);
+  if (!object(signatureValue))
+    throw new TypeError("Update signature is missing.");
+  if (signatureValue.algorithm !== ABSOLUTE_MOBILE_UPDATE_SIGNATURE_ALGORITHM)
+    throw new TypeError("Update signature algorithm is unsupported.");
+  const keyId = requireText(signatureValue.keyId, "Update signature keyId");
+  if (!KEY_ID_PATTERN.test(keyId))
+    throw new TypeError("Update signature keyId is invalid.");
+  const signature = requireText(signatureValue.value, "Update signature value");
+  let signatureBytes;
+  try {
+    signatureBytes = Uint8Array.from(atob(signature), (character) => character.charCodeAt(0));
+  } catch {
+    signatureBytes = new Uint8Array;
+  }
+  if (!/^[A-Za-z0-9+/]+={0,2}$/u.test(signature) || signatureBytes.byteLength !== 64 || btoa(String.fromCharCode(...signatureBytes)) !== signature)
+    throw new TypeError("Update signature is not canonical base64.");
+  return {
+    ...unsigned,
+    signature: {
+      algorithm: ABSOLUTE_MOBILE_UPDATE_SIGNATURE_ALGORITHM,
+      keyId,
+      value: signature
+    }
+  };
+};
+var unsignedAbsoluteMobileUpdate = (manifest) => {
+  const { signature: _signature, ...unsigned } = manifest;
+  return unsigned;
+};
+
+// src/mobile/updateClient.ts
+var exactManifestUrl = (value) => {
+  const url = new URL(value);
+  if (url.protocol !== "https:" && url.hostname !== "localhost" && url.hostname !== "127.0.0.1")
+    throw new TypeError("Mobile update manifests require HTTPS outside loopback development.");
+  if (url.username || url.password || url.hash)
+    throw new TypeError("Mobile update manifest URLs cannot contain credentials or fragments.");
+  return url;
+};
+var fileUrl = (manifestUrl, releaseId, path) => {
+  const encodedPath = path.split("/").map(encodeURIComponent).join("/");
+  const base = new URL(`./${encodeURIComponent(releaseId)}/files/`, manifestUrl);
+  const result = new URL(encodedPath, base);
+  if (result.origin !== manifestUrl.origin || !result.pathname.startsWith(base.pathname))
+    throw new TypeError("Mobile update asset escaped its signed release origin.");
+  return result;
+};
+var readChunks = async (reader, maximum, chunks = [], received = 0) => {
+  const result = await reader.read();
+  if (result.done)
+    return { chunks, received };
+  const total = received + result.value.byteLength;
+  if (total > maximum)
+    throw new TypeError("Mobile update response exceeds its signed size.");
+  chunks.push(result.value);
+  return readChunks(reader, maximum, chunks, total);
+};
+var readBounded = async (response, maximum) => {
+  const declared = Number(response.headers.get("content-length"));
+  if (Number.isFinite(declared) && declared > maximum)
+    throw new TypeError("Mobile update response exceeds its signed size.");
+  if (!response.body)
+    return new Uint8Array;
+  const reader = response.body.getReader();
+  let result;
+  try {
+    result = await readChunks(reader, maximum);
+  } catch (error) {
+    await reader.cancel().catch(() => {
+      return;
+    });
+    throw error;
+  }
+  const contents = new Uint8Array(result.received);
+  let offset = 0;
+  for (const chunk of result.chunks) {
+    contents.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return contents;
+};
+var requestHeaders = (config) => ({
+  "x-absolute-mobile-app": config.appId,
+  "x-absolute-mobile-channel": config.channel,
+  "x-absolute-mobile-installation": config.installationId,
+  "x-absolute-mobile-release": config.currentReleaseId,
+  "x-absolute-mobile-runtime": config.runtimeFingerprint
+});
+var requireCompatible = (manifest, config) => {
+  if (manifest.appId !== config.appId)
+    throw new TypeError("Mobile update belongs to another app.");
+  if (manifest.channel !== config.channel)
+    throw new TypeError("Mobile update belongs to another channel.");
+  if (manifest.runtimeFingerprint !== config.runtimeFingerprint)
+    throw new TypeError("Mobile update requires a different native runtime.");
+};
+var createAbsoluteMobileUpdateClient = (options) => {
+  const manifestUrl = exactManifestUrl(options.config.manifestUrl);
+  const request = options.fetch ?? globalThis.fetch;
+  const downloadFiles = async (manifest, index = 0, received = 0) => {
+    const file = manifest.files[index];
+    if (!file)
+      return received;
+    const asset = await request(fileUrl(manifestUrl, manifest.releaseId, file.path), {
+      cache: "no-store",
+      credentials: "omit",
+      redirect: "error",
+      signal: AbortSignal.timeout(30000)
+    });
+    if (!asset.ok)
+      throw new TypeError(`Mobile update asset ${file.path} failed with HTTP ${asset.status}.`);
+    const contents = await readBounded(asset, file.bytes);
+    const total = received + contents.byteLength;
+    if (contents.byteLength !== file.bytes || total > ABSOLUTE_MOBILE_UPDATE_MAX_TOTAL_BYTES)
+      throw new TypeError(`Mobile update asset ${file.path} has an invalid size.`);
+    if (await options.verifier.digest(contents) !== file.sha256)
+      throw new TypeError(`Mobile update asset ${file.path} failed integrity verification.`);
+    await options.store.write(file, contents);
+    return downloadFiles(manifest, index + 1, total);
+  };
+  const check = async (download = false) => {
+    const response = await request(manifestUrl, {
+      cache: "no-store",
+      credentials: "omit",
+      headers: requestHeaders(options.config),
+      redirect: "error",
+      signal: AbortSignal.timeout(15000)
+    });
+    if (response.status === 204 || response.status === 304)
+      return { kind: "current" };
+    if (!response.ok)
+      throw new TypeError(`Mobile update check failed with HTTP ${response.status}.`);
+    const manifestBytes = await readBounded(response, 1024 * 1024);
+    let manifestValue;
+    try {
+      manifestValue = JSON.parse(new TextDecoder().decode(manifestBytes));
+    } catch {
+      throw new TypeError("Mobile update manifest is not valid JSON.");
+    }
+    const manifest = parseAbsoluteMobileUpdateManifest(manifestValue);
+    requireCompatible(manifest, options.config);
+    if (!await options.verifier.verify(manifest))
+      throw new TypeError("Mobile update signature verification failed.");
+    if (manifest.releaseId === options.config.currentReleaseId)
+      return { kind: "current" };
+    if (options.config.blockedReleaseIds?.includes(manifest.releaseId))
+      return { kind: "quarantined", releaseId: manifest.releaseId };
+    if (!download)
+      return { kind: "update-available", manifest };
+    await options.store.begin(manifest);
+    try {
+      await downloadFiles(manifest);
+      await options.store.commit(manifest);
+    } catch (error) {
+      await options.store.abort(manifest.releaseId);
+      throw error;
+    }
+    return { kind: "downloaded", manifest };
+  };
+  return {
+    check,
+    activate: (releaseId) => options.store.activate(releaseId),
+    download: () => check(true)
+  };
+};
+
+// src/mobile/shellUpdate.ts
+var STATE_KEY = "absolute.mobile.update.state.v1";
+var INSTALLATION_KEY = "absolute.mobile.update.installation.v1";
+var ROOT = "NoCloud/ionic_built_snapshots";
+var watchdog = registerPlugin("AbsoluteMobileUpdateWatchdog");
+var base64Bytes = (value) => Uint8Array.from(atob(value), (character) => character.charCodeAt(0));
+var arrayBuffer = (value) => new Uint8Array(value).buffer;
+var bytesBase64 = (value) => {
+  let result = "";
+  const size = 32768;
+  for (let offset = 0;offset < value.length; offset += size) {
+    result += String.fromCharCode(...value.subarray(offset, offset + size));
+  }
+  return btoa(result);
+};
+var readState = async () => {
+  const { value } = await Preferences.get({ key: STATE_KEY });
+  if (!value)
+    return {};
+  try {
+    const parsed = JSON.parse(value);
+    if (typeof parsed !== "object" || parsed === null)
+      return {};
+    const text = (key) => {
+      const candidate = Reflect.get(parsed, key);
+      return typeof candidate === "string" ? candidate : undefined;
+    };
+    const number = (key) => {
+      const candidate = Reflect.get(parsed, key);
+      return typeof candidate === "number" && Number.isFinite(candidate) ? candidate : undefined;
+    };
+    const recoveryValue = Reflect.get(parsed, "recovery");
+    const quarantineValue = Reflect.get(parsed, "quarantinedReleases");
+    const quarantinedReleases = Array.isArray(quarantineValue) ? [
+      ...new Set(quarantineValue.filter((candidateRelease) => typeof candidateRelease === "string" && /^amu_[a-f0-9]{64}$/u.test(candidateRelease)))
+    ].slice(-8) : [];
+    const recovery = typeof recoveryValue === "object" && recoveryValue !== null ? {
+      durationMs: Reflect.get(recoveryValue, "durationMs"),
+      reason: Reflect.get(recoveryValue, "reason"),
+      releaseId: Reflect.get(recoveryValue, "releaseId")
+    } : undefined;
+    let validRecovery;
+    if (recovery && typeof recovery.durationMs === "number" && Number.isFinite(recovery.durationMs) && recovery.durationMs >= 0 && (recovery.reason === "boot-interrupted" || recovery.reason === "boot-timeout") && typeof recovery.releaseId === "string")
+      validRecovery = {
+        durationMs: recovery.durationMs,
+        reason: recovery.reason,
+        releaseId: recovery.releaseId
+      };
+    return {
+      ...text("activeRelease") ? { activeRelease: text("activeRelease") } : {},
+      ...text("pendingRelease") ? { pendingRelease: text("pendingRelease") } : {},
+      ...number("pendingStartedAt") === undefined ? {} : { pendingStartedAt: number("pendingStartedAt") },
+      ...text("previousPath") ? { previousPath: text("previousPath") } : {},
+      ...quarantinedReleases.length > 0 ? { quarantinedReleases } : {},
+      ...text("readyRelease") ? { readyRelease: text("readyRelease") } : {},
+      ...validRecovery ? { recovery: validRecovery } : {}
+    };
+  } catch {
+    return {};
+  }
+};
+var writeState = (state) => Preferences.set({ key: STATE_KEY, value: JSON.stringify(state) });
+var installationId = async () => {
+  const existing = await Preferences.get({ key: INSTALLATION_KEY });
+  if (existing.value && /^[a-f0-9-]{36}$/u.test(existing.value))
+    return existing.value;
+  const value = crypto.randomUUID();
+  await Preferences.set({ key: INSTALLATION_KEY, value });
+  return value;
+};
+var isIonicWebView = (value) => typeof value === "object" && value !== null && typeof Reflect.get(value, "getServerBasePath") === "function" && typeof Reflect.get(value, "setServerBasePath") === "function" && typeof Reflect.get(value, "persistServerBasePath") === "function";
+var webView = () => {
+  const ionic = Reflect.get(globalThis, "Ionic");
+  const provider = typeof ionic === "object" && ionic !== null ? Reflect.get(ionic, "WebView") : undefined;
+  if (!isIonicWebView(provider))
+    throw new TypeError("Capacitor WebView update controls are unavailable.");
+  return provider;
+};
+var currentServerBasePath = () => new Promise((resolve) => webView().getServerBasePath(resolve));
+var releasePath = (releaseId) => `${ROOT}/${releaseId}`;
+var releaseNativePath = async (releaseId) => {
+  const { uri } = await Filesystem.getUri({
+    directory: Directory.Library,
+    path: releasePath(releaseId)
+  });
+  const url = new URL(uri);
+  return decodeURIComponent(url.pathname);
+};
+var removeRelease = async (releaseId) => {
+  await Filesystem.rmdir({
+    directory: Directory.Library,
+    path: releasePath(releaseId),
+    recursive: true
+  }).catch(() => {
+    return;
+  });
+};
+var createStore = () => {
+  let staging;
+  return {
+    abort: async (releaseId) => {
+      staging = undefined;
+      await removeRelease(releaseId);
+      const state = await readState();
+      if (state.readyRelease === releaseId || state.pendingRelease === releaseId)
+        await writeState({
+          activeRelease: state.activeRelease,
+          quarantinedReleases: state.quarantinedReleases,
+          recovery: state.recovery
+        });
+    },
+    activate: async (releaseId) => {
+      const state = await readState();
+      if (state.readyRelease !== releaseId)
+        throw new TypeError("Mobile update is not committed and ready to activate.");
+      const path = await releaseNativePath(releaseId);
+      const previousPath = await currentServerBasePath();
+      await writeState({
+        activeRelease: state.activeRelease,
+        pendingRelease: releaseId,
+        pendingStartedAt: Date.now(),
+        previousPath,
+        quarantinedReleases: state.quarantinedReleases
+      });
+      try {
+        await watchdog.arm({ releaseId });
+        webView().setServerBasePath(path);
+      } catch (error) {
+        await watchdog.confirm({ releaseId }).catch(() => {
+          return;
+        });
+        await removeRelease(releaseId);
+        await writeState({
+          activeRelease: state.activeRelease,
+          quarantinedReleases: state.quarantinedReleases
+        });
+        throw error;
+      }
+    },
+    begin: async (manifest) => {
+      await removeRelease(manifest.releaseId);
+      await Filesystem.mkdir({
+        directory: Directory.Library,
+        path: releasePath(manifest.releaseId),
+        recursive: true
+      });
+      staging = manifest;
+    },
+    commit: async (manifest) => {
+      if (staging?.releaseId !== manifest.releaseId)
+        throw new TypeError("Mobile update staging transaction changed identity.");
+      const state = await readState();
+      await writeState({
+        activeRelease: state.activeRelease,
+        quarantinedReleases: state.quarantinedReleases,
+        readyRelease: manifest.releaseId
+      });
+      staging = undefined;
+    },
+    write: async (file, contents) => {
+      if (!staging || !staging.files.some((candidate) => candidate.path === file.path))
+        throw new TypeError("Mobile update write is outside its staging transaction.");
+      await Filesystem.writeFile({
+        data: bytesBase64(contents),
+        directory: Directory.Library,
+        path: `${releasePath(staging.releaseId)}/${file.path}`,
+        recursive: true
+      });
+    }
+  };
+};
+var createVerifier = (publicKeys) => ({
+  digest: async (contents) => {
+    const digest = new Uint8Array(await crypto.subtle.digest("SHA-256", arrayBuffer(contents)));
+    return [...digest].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+  },
+  verify: async (manifest) => {
+    const encoded = publicKeys[manifest.signature.keyId];
+    if (!encoded)
+      return false;
+    try {
+      const key = await crypto.subtle.importKey("spki", arrayBuffer(base64Bytes(encoded)), { name: "ECDSA", namedCurve: "P-256" }, false, ["verify"]);
+      return crypto.subtle.verify({ hash: "SHA-256", name: "ECDSA" }, key, arrayBuffer(base64Bytes(manifest.signature.value)), arrayBuffer(absoluteMobileUpdateSigningPayload(unsignedAbsoluteMobileUpdate(manifest))));
+    } catch {
+      return false;
+    }
+  }
+});
+var emitUpdateResult = (detail) => dispatchEvent(new CustomEvent("absolute:mobile-update", { detail }));
+var removePriorRelease = async (prior, active) => {
+  if (prior && prior !== active)
+    await removeRelease(prior);
+};
+var reconcilePendingRelease = async (store, state) => {
+  if (!state.pendingRelease)
+    return state;
+  const pendingPath = await releaseNativePath(state.pendingRelease);
+  const currentPath = await currentServerBasePath();
+  if (currentPath !== pendingPath) {
+    const failed = state.pendingRelease;
+    await store.abort(failed);
+    emitUpdateResult({ kind: "rolled-back", releaseId: failed });
+    return readState();
+  }
+  webView().persistServerBasePath();
+  const next = { activeRelease: state.pendingRelease };
+  await writeState(next);
+  await watchdog.confirm({ releaseId: state.pendingRelease });
+  await removePriorRelease(state.activeRelease, next.activeRelease);
+  emitUpdateResult({ kind: "activated", releaseId: next.activeRelease });
+  return next;
+};
+var consumeNativeRecovery = async (state) => {
+  if (!state.recovery)
+    return state;
+  const { recovery, ...next } = state;
+  emitUpdateResult({
+    durationMs: Math.round(recovery.durationMs),
+    kind: "rolled-back",
+    reason: recovery.reason,
+    releaseId: recovery.releaseId
+  });
+  await writeState(next);
+  return next;
+};
+var installAbsoluteMobileShellUpdates = async (manifest) => {
+  if (!manifest.updates)
+    return;
+  const store = createStore();
+  const recovered = await consumeNativeRecovery(await readState());
+  const state = await reconcilePendingRelease(store, recovered);
+  const client = createAbsoluteMobileUpdateClient({
+    config: {
+      appId: manifest.appId,
+      blockedReleaseIds: state.quarantinedReleases ?? [],
+      channel: manifest.updates.channel,
+      currentReleaseId: state.activeRelease ?? `embedded:${manifest.appBuild}`,
+      installationId: await installationId(),
+      manifestUrl: manifest.updates.manifestUrl,
+      runtimeFingerprint: manifest.nativeRuntime
+    },
+    store,
+    verifier: createVerifier(manifest.updates.publicKeys)
+  });
+  const activateDownloaded = async (result) => {
+    if (result.kind !== "downloaded")
+      return;
+    emitUpdateResult({
+      kind: "downloaded",
+      releaseId: result.manifest.releaseId
+    });
+    await client.activate(result.manifest.releaseId);
+  };
+  client.download().then((result) => {
+    if (result.kind === "quarantined") {
+      emitUpdateResult({
+        kind: "quarantined",
+        releaseId: result.releaseId
+      });
+      return;
+    }
+    return activateDownloaded(result);
+  }).catch((error) => {
+    console.error("[Absolute Mobile] Update failed:", error);
+    emitUpdateResult({ kind: "failed" });
+  });
+};
+export {
+  installAbsoluteMobileShellUpdates
+};