omi/web/admin/lib/desktop-release-lifecycle.ts at websearch-dev-test · ghzhost/omi · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
export type DesktopReleaseChannel = "candidate" | "beta" | "stable" | null;
export type DesktopReleaseLifecycle =
  "build_candidate" | "qualified_beta" | "stable_candidate" | "stable";

export interface DesktopQualification {
  qualified: boolean;
  qualifiedAt: string | null;
  evidence: string | null;
  source: "canonical" | "legacy";
}

export interface DesktopStableCandidate {
  complete: boolean;
  nominatedAt: string | null;
  nominatedBy: string | null;
}

const LIFECYCLE_LABELS: Record<DesktopReleaseLifecycle, string> = {
  build_candidate: "Build candidate",
  qualified_beta: "Qualified beta",
  stable_candidate: "Stable candidate",
  stable: "Stable",
};

export function desktopReleaseLifecycleLabel(
  lifecycle: DesktopReleaseLifecycle,
): string {
  return LIFECYCLE_LABELS[lifecycle];
}

function isTrueMetadata(value: string | undefined): boolean {
  const normalized = value?.trim().toLowerCase();
  return normalized === "true" || normalized === "1" || normalized === "yes";
}

export function desktopQualificationFromMetadata(
  metadata: Record<string, string>,
): DesktopQualification {
  if (Object.prototype.hasOwnProperty.call(metadata, "qualifiedBeta")) {
    return {
      qualified: isTrueMetadata(metadata.qualifiedBeta),
      qualifiedAt: metadata.qualifiedBetaAt?.trim() || null,
      evidence: metadata.qualifiedBetaEvidence?.trim() || null,
      source: "canonical",
    };
  }
  return {
    qualified: isTrueMetadata(metadata.blessed),
    qualifiedAt: metadata.blessedAt?.trim() || null,
    evidence: metadata.blessedEvidence?.trim() || null,
    source: "legacy",
  };
}

export function desktopStableCandidateFromMetadata(
  metadata: Record<string, string>,
  expected: { releaseTag: string; qualificationEvidence: string | null },
): DesktopStableCandidate {
  const required = [
    metadata.stableCandidateTag,
    metadata.stableCandidateSha,
    metadata.stableCandidateAt,
    metadata.stableCandidateBy,
    metadata.stableCandidateRationale,
    metadata.stableCandidateQualificationEvidence,
    metadata.stableCandidateSoakReview,
    metadata.stableCandidateTelemetryReview,
    metadata.stableCandidateReleaseNotesReview,
  ];
  const referencesCurrentRelease =
    metadata.stableCandidateTag?.trim() === expected.releaseTag &&
    Boolean(expected.qualificationEvidence) &&
    metadata.stableCandidateQualificationEvidence?.trim() ===
      expected.qualificationEvidence;
  return {
    complete:
      isTrueMetadata(metadata.stableCandidate) &&
      required.every((value) => Boolean(value?.trim())) &&
      referencesCurrentRelease,
    nominatedAt: metadata.stableCandidateAt?.trim() || null,
    nominatedBy: metadata.stableCandidateBy?.trim() || null,
  };
}

export function desktopReleaseLifecycle(
  channel: DesktopReleaseChannel,
  qualification: DesktopQualification,
  stableCandidate: DesktopStableCandidate,
): DesktopReleaseLifecycle {
  if (channel === "stable") return "stable";
  if (qualification.qualified && stableCandidate.complete)
    return "stable_candidate";
  if (qualification.qualified) return "qualified_beta";
  return "build_candidate";
}