@hot-updater/console 1.0.0-rc.8 → 1.0.0

package/src/lib/server/bundle-signing.server.ts

@@ -1,23 +0,0 @@
-import type { ConsoleSigningConfig } from "../../index";
-
-const DEFAULT_PROVIDER = "Configured provider";
-
-export type BundleSigningInspection =
-  | { readonly status: "disabled" }
-  | {
-      readonly status: "enabled";
-      readonly provider: string;
-      readonly algorithm: "RSA-SHA256";
-    };
-
-export const inspectBundleSigning = async (
-  signing: ConsoleSigningConfig | undefined,
-): Promise<BundleSigningInspection> => {
-  if (!signing?.enabled) return { status: "disabled" };
-
-  return {
-    algorithm: "RSA-SHA256",
-    provider: signing.provider ?? DEFAULT_PROVIDER,
-    status: "enabled",
-  };
-};

package/src/lib/server/deleteBundle.ts

@@ -1,145 +0,0 @@
-import {
-  getBundlePatches,
-  getManifestStorageUri,
-  getPatchStorageUri,
-} from "@hot-updater/core";
-import type {
-  Bundle,
-  DatabaseClient,
-  StoragePluginWith,
-} from "@hot-updater/plugin-core";
-
-interface DeleteBundleInput {
-  bundleId: string;
-}
-
-interface DeleteBundlesInput {
-  bundleIds: readonly string[];
-}
-
-interface DeleteBundleDependencies {
-  databaseClient: DatabaseClient;
-  storagePlugin: StoragePluginWith<"delete">;
-  waitForStorageCleanup?: boolean;
-}
-
-function resolveStorageUriForDeletion(
-  storageUri: string,
-  storagePlugin: StoragePluginWith<"delete">,
-) {
-  const protocol = new URL(storageUri).protocol.replace(":", "");
-
-  if (storagePlugin.protocol === protocol) {
-    return storageUri;
-  }
-
-  if (protocol === "http" || protocol === "https") {
-    return null;
-  }
-
-  throw new Error(`No storage plugin for protocol: ${protocol}`);
-}
-
-async function cleanupBundleStorage(
-  bundle: Bundle,
-  storagePlugin: StoragePluginWith<"delete">,
-) {
-  const cleanupUris = new Set<string>();
-  const addCleanupUri = (storageUri: string | undefined) => {
-    if (!storageUri) return;
-    const resolvedStorageUri = resolveStorageUriForDeletion(
-      storageUri,
-      storagePlugin,
-    );
-    if (resolvedStorageUri) cleanupUris.add(resolvedStorageUri);
-  };
-
-  addCleanupUri(bundle.storageUri);
-  addCleanupUri(getManifestStorageUri(bundle) ?? undefined);
-  addCleanupUri(getPatchStorageUri(bundle) ?? undefined);
-  for (const patch of getBundlePatches(bundle)) {
-    addCleanupUri(patch.patchStorageUri);
-  }
-
-  for (const storageUri of cleanupUris) {
-    try {
-      await storagePlugin.delete({ storageUri });
-    } catch (error) {
-      console.error("Failed to delete bundle from storage:", error);
-    }
-  }
-}
-
-export async function deleteBundles(
-  { bundleIds }: DeleteBundlesInput,
-  {
-    databaseClient,
-    storagePlugin,
-    waitForStorageCleanup = true,
-  }: DeleteBundleDependencies,
-) {
-  const uniqueBundleIds = [...new Set(bundleIds)];
-  const { data: matchedBundles } = await databaseClient.getBundles({
-    where: { id: { in: uniqueBundleIds } },
-    limit: uniqueBundleIds.length,
-  });
-  const matchedById = new Map(
-    matchedBundles.map((bundle) => [bundle.id, bundle]),
-  );
-  const bundles = uniqueBundleIds.flatMap((bundleId) => {
-    const bundle = matchedById.get(bundleId);
-    return bundle ? [bundle] : [];
-  });
-  const missingBundleIds = uniqueBundleIds.filter(
-    (bundleId) => !matchedById.has(bundleId),
-  );
-
-  for (const bundle of bundles) {
-    const cleanupCandidates = [
-      bundle.storageUri,
-      getManifestStorageUri(bundle),
-      getPatchStorageUri(bundle),
-      ...getBundlePatches(bundle).map((patch) => patch.patchStorageUri),
-    ].filter((value): value is string => Boolean(value));
-    for (const candidate of cleanupCandidates) {
-      resolveStorageUriForDeletion(candidate, storagePlugin);
-    }
-  }
-
-  if (bundles.length > 0) {
-    await databaseClient.mutate(async (mutation) => {
-      for (const bundle of bundles) {
-        await mutation.deleteBundleById(bundle.id);
-      }
-    });
-  }
-
-  const cleanupStorage = async () => {
-    for (const bundle of bundles) {
-      await cleanupBundleStorage(bundle, storagePlugin);
-    }
-  };
-
-  if (waitForStorageCleanup) {
-    await cleanupStorage();
-  } else {
-    void cleanupStorage().catch((error) => {
-      console.error("Failed to clean up bundle storage:", error);
-    });
-  }
-
-  return {
-    deletedBundleIds: bundles.map((bundle) => bundle.id),
-    missingBundleIds,
-  };
-}
-
-export async function deleteBundle(
-  { bundleId }: DeleteBundleInput,
-  dependencies: DeleteBundleDependencies,
-) {
-  const result = await deleteBundles({ bundleIds: [bundleId] }, dependencies);
-  if (result.missingBundleIds.length > 0) {
-    throw new Error(`Bundle not found: ${bundleId}`);
-  }
-}

package/src/lib/server/insightsHistory.ts

@@ -1,52 +0,0 @@
-import type {
-  BundleEventRow,
-  InsightsEventCursor,
-  InsightsModel,
-} from "@hot-updater/plugin-core";
-
-import { recoveryWindows, type RecoveryInput } from "../insights-recovery";
-
-export async function readInsightsHistory(
-  model: InsightsModel,
-  window: RecoveryInput["window"],
-  beforeReceivedAtMs = Date.now(),
-) {
-  const { durationMs, intervalMs } = recoveryWindows[window];
-  const sinceMs = Math.max(0, beforeReceivedAtMs - durationMs);
-  let completeSinceMs = sinceMs;
-  let after: InsightsEventCursor | undefined;
-  let truncated = false;
-  const events: BundleEventRow[] = [];
-  while (events.length < 50_000) {
-    const limit = Math.min(100, 50_000 - events.length);
-    const rows = await model.listEvents({
-      filter: { kind: "all" },
-      sinceMs,
-      beforeReceivedAtMs,
-      after,
-      limit: limit + 1,
-    });
-    const page = rows.slice(0, limit);
-    events.push(...page);
-    const last = page.at(-1);
-    if (!last || rows.length <= limit) break;
-    after = { id: last.id, receivedAtMs: last.received_at_ms };
-    if (events.length === 50_000) {
-      truncated = true;
-      // Exclude the partially read interval, including its unknown denominator.
-      completeSinceMs =
-        Math.floor(last.received_at_ms / intervalMs) * intervalMs + intervalMs;
-    }
-  }
-  return {
-    events: events
-      .filter((row) => row.received_at_ms >= completeSinceMs)
-      .reverse(),
-    sinceMs: completeSinceMs,
-    beforeReceivedAtMs,
-    intervalMs,
-    truncated,
-  };
-}
-
-export type InsightsHistory = Awaited<ReturnType<typeof readInsightsHistory>>;

package/src/lib/server/insightsRecovery.ts

@@ -1,187 +0,0 @@
-import type { InsightsModel } from "@hot-updater/plugin-core";
-
-import {
-  readRecoveryInput,
-  type RecoveryInput,
-  type RecoveryReport,
-  type RecoverySeries,
-} from "../insights-recovery";
-import { readInsightsHistory, type InsightsHistory } from "./insightsHistory";
-
-export async function getRecoveryReport(
-  model: InsightsModel,
-  input: RecoveryInput,
-  beforeReceivedAtMs = Date.now(),
-): Promise<RecoveryReport> {
-  readRecoveryInput(input);
-  return buildRecoveryReport(
-    await readInsightsHistory(model, input.window, beforeReceivedAtMs),
-    input,
-  );
-}
-
-export function buildRecoveryReport(
-  history: InsightsHistory,
-  input: RecoveryInput,
-): RecoveryReport {
-  const { events, sinceMs, beforeReceivedAtMs, intervalMs, truncated } =
-    history;
-  const bucketStart = (time: number) =>
-    Math.floor(time / intervalMs) * intervalMs;
-  const releases = new Map<
-    string,
-    {
-      firstAppliedAtMs: number | null;
-      recovered: Set<string>;
-      buckets: Map<
-        number,
-        {
-          applied: number;
-          recovered: number;
-          installations: Set<string>;
-          lastRecoveredAtMs: number;
-        }
-      >;
-    }
-  >();
-  const ensureRelease = (id: string) => {
-    let release = releases.get(id);
-    if (!release) {
-      release = {
-        firstAppliedAtMs: null,
-        recovered: new Set(),
-        buckets: new Map(),
-      };
-      releases.set(id, release);
-    }
-    return release;
-  };
-  const latest = new Map<
-    string,
-    { releaseId: string | null; bundleId: string; inScope: boolean }
-  >();
-  const active = new Map<string, number>();
-  const snapshots = new Map<number, Map<string, number> | null>();
-  let unattributedInstallations = 0;
-  let observed = false;
-  let eventIndex = 0;
-  for (
-    let startMs = bucketStart(sinceMs);
-    startMs < beforeReceivedAtMs;
-    startMs += intervalMs
-  ) {
-    while (
-      eventIndex < events.length &&
-      events[eventIndex].received_at_ms < startMs + intervalMs
-    ) {
-      const row = events[eventIndex++];
-      const inScope =
-        (input.platform === "all" || row.platform === input.platform) &&
-        row.channel === input.channel &&
-        (input.appVersion === undefined ||
-          row.app_version === input.appVersion);
-      const previous = latest.get(row.install_id);
-      // Lifecycle reports can omit the ID on UNCHANGED. Only retain an observed ID for the same file and scope.
-      const releaseId =
-        row.to_release_id ??
-        (row.type === "UNCHANGED" &&
-        previous?.bundleId === row.to_bundle_id &&
-        previous.inScope === inScope
-          ? previous.releaseId
-          : null);
-      if (previous?.inScope) {
-        if (previous.releaseId)
-          active.set(
-            previous.releaseId,
-            (active.get(previous.releaseId) ?? 0) - 1,
-          );
-        else unattributedInstallations -= 1;
-      }
-      latest.set(row.install_id, {
-        releaseId,
-        bundleId: row.to_bundle_id,
-        inScope,
-      });
-      if (!inScope) continue;
-      observed = true;
-      if (releaseId) {
-        ensureRelease(releaseId);
-        active.set(releaseId, (active.get(releaseId) ?? 0) + 1);
-      } else unattributedInstallations += 1;
-      if (row.from_release_id) ensureRelease(row.from_release_id);
-      const outcomeId =
-        row.type === "RECOVERED" ? row.from_release_id : row.to_release_id;
-      if (
-        !outcomeId ||
-        (row.type !== "RECOVERED" && row.type !== "UPDATE_APPLIED")
-      )
-        continue;
-      const release = ensureRelease(outcomeId);
-      const bucket = release.buckets.get(startMs) ?? {
-        applied: 0,
-        recovered: 0,
-        installations: new Set<string>(),
-        lastRecoveredAtMs: -1,
-      };
-      if (row.type === "RECOVERED") {
-        bucket.recovered += 1;
-        bucket.installations.add(row.install_id);
-        bucket.lastRecoveredAtMs = row.received_at_ms;
-        release.recovered.add(row.install_id);
-      } else {
-        bucket.applied += 1;
-        release.firstAppliedAtMs ??= row.received_at_ms;
-      }
-      release.buckets.set(startMs, bucket);
-    }
-    // Before the first report there is no observed installation state to chart.
-    snapshots.set(startMs, observed ? new Map(active) : null);
-  }
-  const series: RecoverySeries[] = [];
-  for (const [releaseId, release] of releases) {
-    if (input.releaseId && input.releaseId !== releaseId) continue;
-    let previousRate: number | null = null;
-    const points = Array.from(snapshots, ([startMs, snapshot]) => {
-      const bucket = release.buckets.get(startMs);
-      const applied = bucket?.applied ?? 0;
-      const recovered = bucket?.recovered ?? 0;
-      const total = applied + recovered;
-      const rate = total === 0 ? null : (recovered / total) * 100;
-      const spike =
-        release.firstAppliedAtMs !== null &&
-        (bucket?.lastRecoveredAtMs ?? -1) >= release.firstAppliedAtMs &&
-        (!truncated || previousRate !== null) &&
-        rate !== null &&
-        total >= 10 &&
-        recovered >= 3 &&
-        rate >= 10 &&
-        rate - (previousRate ?? 0) >= 10;
-      if (rate !== null) previousRate = rate;
-      return {
-        startMs,
-        active: snapshot ? (snapshot.get(releaseId) ?? 0) : null,
-        recoveredInstallations: bucket?.installations.size ?? 0,
-        applied,
-        recovered,
-        rate,
-        spike,
-      };
-    });
-    series.push({
-      releaseId,
-      firstAppliedAtMs: release.firstAppliedAtMs,
-      activeInstallations: active.get(releaseId) ?? 0,
-      recoveredInstallations: release.recovered.size,
-      points,
-    });
-  }
-  series.sort((a, b) => b.releaseId.localeCompare(a.releaseId));
-  return {
-    sinceMs,
-    beforeReceivedAtMs,
-    intervalMs,
-    truncated,
-    unattributedInstallations,
-    series,
-  };
-}

package/src/routes/signing.tsx

@@ -1,37 +0,0 @@
-import { createFileRoute } from "@tanstack/react-router";
-import { ShieldCheck } from "lucide-react";
-
-import { BundleSigningPage } from "@/components/features/signing/BundleSigningPage";
-import { Badge } from "@/components/ui/badge";
-import { SidebarTrigger } from "@/components/ui/sidebar";
-
-export const Route = createFileRoute("/signing")({
-  component: BundleSigningRoute,
-});
-
-function BundleSigningRoute() {
-  return (
-    <div className="flex h-svh min-h-0 flex-col">
-      <header className="sticky top-0 z-10 flex shrink-0 flex-wrap items-center gap-x-3 gap-y-1 border-b bg-background px-3 py-3 sm:min-h-12 sm:flex-nowrap sm:bg-card/70 sm:px-4 sm:backdrop-blur-sm">
-        <SidebarTrigger className="-ml-1" />
-        <div className="flex items-center gap-1.5">
-          <ShieldCheck
-            aria-hidden="true"
-            className="size-3.5 text-muted-foreground"
-          />
-          <h1 className="text-sm font-medium">Bundle signing</h1>
-        </div>
-        <Badge variant="outline">Read-only</Badge>
-        <p className="basis-full pl-9 text-xs text-muted-foreground sm:basis-auto sm:pl-0">
-          Inspect the public key used to verify signed updates.
-        </p>
-      </header>
-
-      <div className="min-h-0 min-w-0 flex-1 overflow-y-auto bg-muted/5 p-3 sm:p-6">
-        <div className="mx-auto w-full max-w-5xl">
-          <BundleSigningPage />
-        </div>
-      </div>
-    </div>
-  );
-}