@dotobokuri/fleet-cli 1.10.1 → 1.11.0

package/dist/index.js

@@ -81620,6 +81620,170 @@ function resolvedWorkspaceSnapshot(resolveWorkspace, tenantId) {
     tenantLabel: tenantId
   };
 }
+var RELEASE_NOTE_HEADINGS = ["Added", "Changed", "Fixed", "Removed", "Breaking Changes"];
+var VERSION_HEADER_PATTERN = /^## \[([^\]]+)\](?: - ([0-9]{4}-[0-9]{2}-[0-9]{2}))?$/;
+var SECTION_HEADER_PATTERN = /^### (Added|Changed|Fixed|Removed|Breaking Changes)$/;
+var BULLET_PATTERN = /^- (.+)$/;
+var PACKAGE_TAG_PATTERN = /^\[([^\]]+)\]/;
+function parseConsoleReleaseNotes(changelog) {
+  const lines = changelog.split(/\r?\n/);
+  const notes = [];
+  for (let index = 0; index < lines.length; index += 1) {
+    const match = VERSION_HEADER_PATTERN.exec(lines[index] ?? "");
+    if (match === null) continue;
+    const block = [];
+    for (let cursor = index + 1; cursor < lines.length; cursor += 1) {
+      if ((lines[cursor] ?? "").startsWith("## ")) break;
+      block.push(lines[cursor] ?? "");
+    }
+    const sections = collectSections(block);
+    if (sections.length === 0) continue;
+    notes.push({ version: match[1] ?? "", date: match[2] ?? null, sections });
+  }
+  return notes;
+}
+function collectSections(lines) {
+  const sections = [];
+  let current = null;
+  for (const line of lines) {
+    const sectionMatch = SECTION_HEADER_PATTERN.exec(line);
+    if (sectionMatch !== null) {
+      current = { heading: sectionMatch[1], items: [] };
+      sections.push(current);
+      continue;
+    }
+    if (current === null) continue;
+    if (line.startsWith("### ")) {
+      current = null;
+      continue;
+    }
+    const bulletMatch = BULLET_PATTERN.exec(line);
+    if (bulletMatch !== null) current.items.push(parseReleaseNoteItem(bulletMatch[1] ?? ""));
+  }
+  return RELEASE_NOTE_HEADINGS.map((heading) => sections.find((section22) => section22.heading === heading)).filter((section22) => Boolean(section22 && section22.items.length > 0));
+}
+function parseReleaseNoteItem(rawText) {
+  const packageTags = [];
+  let text = rawText.trim();
+  while (true) {
+    const match = PACKAGE_TAG_PATTERN.exec(text);
+    if (match === null) break;
+    packageTags.push(match[1] ?? "");
+    text = text.slice(match[0].length).trimStart();
+  }
+  return { packageTags, text: text.trim() };
+}
+var ConsoleReleaseNotesUnavailableError = class extends Error {
+  reason;
+  constructor(reason) {
+    super("Console release notes are unavailable");
+    this.name = "ConsoleReleaseNotesUnavailableError";
+    this.reason = reason;
+  }
+};
+var RAW_CHANGELOG_URL = "https://raw.githubusercontent.com/sbluemin/fleet-harness/main/CHANGELOG.md";
+var SOURCE_REF = "main";
+var FETCH_TIMEOUT_MS = 3e3;
+var MAX_CHANGELOG_BYTES = 1024 * 1024;
+var SUCCESS_TTL_MS = 60 * 60 * 1e3;
+var NEGATIVE_TTL_MS = 30 * 1e3;
+function createConsoleReleaseNotesService(deps = {}) {
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  const now = deps.now ?? (() => Date.now());
+  const setTimer = deps.setTimeout ?? setTimeout;
+  const clearTimer = deps.clearTimeout ?? clearTimeout;
+  let lastSuccess = null;
+  let lastFailureAt = 0;
+  let inFlight = null;
+  let forceInFlight = null;
+  async function refresh(options2 = {}) {
+    const currentTime = now();
+    if (options2.force) {
+      if (forceInFlight) return forceInFlight;
+      const pending2 = runFetch().finally(() => {
+        if (forceInFlight === pending2) forceInFlight = null;
+      });
+      forceInFlight = pending2;
+      return pending2;
+    }
+    if (lastSuccess && currentTime - lastSuccess.fetchedAt < SUCCESS_TTL_MS) return lastSuccess;
+    if (lastFailureAt > 0 && currentTime - lastFailureAt < NEGATIVE_TTL_MS) {
+      if (lastSuccess) return { ...lastSuccess, stale: true };
+      throw new ConsoleReleaseNotesUnavailableError("negative_cache");
+    }
+    if (inFlight) return inFlight;
+    const pending = runFetch().finally(() => {
+      if (inFlight === pending) inFlight = null;
+    });
+    inFlight = pending;
+    return pending;
+  }
+  function runFetch() {
+    return fetchReleaseNotes().then((result) => {
+      lastSuccess = result;
+      lastFailureAt = 0;
+      return result;
+    }).catch((error512) => {
+      lastFailureAt = now();
+      if (lastSuccess) return { ...lastSuccess, stale: true };
+      if (error512 instanceof ConsoleReleaseNotesUnavailableError) throw error512;
+      throw new ConsoleReleaseNotesUnavailableError("cold_unavailable");
+    });
+  }
+  async function fetchReleaseNotes() {
+    const controller = new AbortController();
+    const timer = setTimer(() => controller.abort(), FETCH_TIMEOUT_MS);
+    timer.unref?.();
+    try {
+      const response = await fetchImpl(RAW_CHANGELOG_URL, {
+        headers: { Accept: "text/plain; charset=utf-8" },
+        signal: controller.signal
+      });
+      if (!response.ok) throw new ConsoleReleaseNotesUnavailableError("cold_unavailable");
+      const text = await readTextWithByteLimit(response, controller);
+      return {
+        notes: parseConsoleReleaseNotes(text),
+        sourceRef: SOURCE_REF,
+        fetchedAt: now(),
+        stale: false
+      };
+    } finally {
+      clearTimer(timer);
+    }
+  }
+  return { refresh };
+}
+async function readTextWithByteLimit(response, controller) {
+  const body = response.body;
+  if (body === null) return await response.text();
+  const reader = body.getReader();
+  const chunks = [];
+  let totalBytes = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      totalBytes += value.byteLength;
+      if (totalBytes > MAX_CHANGELOG_BYTES) {
+        controller.abort();
+        throw new ConsoleReleaseNotesUnavailableError("cold_unavailable");
+      }
+      chunks.push(value);
+    }
+    return new TextDecoder().decode(joinChunks22(chunks, totalBytes));
+  } finally {
+    reader.releaseLock();
+  }
+}
+function joinChunks22(chunks, totalBytes) {
+  const joined = new Uint8Array(totalBytes);
+  let offset = 0;
+  for (const chunk of chunks) {
+    joined.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return joined;
+}
 var TENANT_EVENT_LIMIT = 1e3;
 var TENANT_FINALIZED_JOB_LIMIT = 100;
 var TENANT_JOB_LIMIT = 200;
@@ -83540,6 +83704,13 @@ var SERVER_API_CATALOG = [
     category: "Observer",
     gate: "loopback"
   },
+  {
+    method: "GET",
+    path: "/observer/release-notes",
+    summary: "Get the console release notes.",
+    category: "Update",
+    gate: "loopback"
+  },
   {
     method: "GET",
     path: "/observer/tenants",
@@ -83691,6 +83862,7 @@ function createConsoleServer(deps = {}) {
   registerDefaultCarriers2(carrierRegistry);
   const lock = createConsoleLock({ hostname: () => host });
   const observability = createConsoleObservabilityStore();
+  const releaseNotes = deps.releaseNotes ?? createConsoleReleaseNotesService();
   const updateCheck = deps.updateCheck ?? createConsoleUpdateCheckService();
   const updateApply = deps.updateApply ?? createConsoleUpdateApplyService();
   const theaters = new TheaterRegistry();
@@ -83885,6 +84057,10 @@ function createConsoleServer(deps = {}) {
       handleObserverApiCatalog(req, res);
       return;
     }
+    if (pathname === "/observer/release-notes") {
+      runAsyncHandler(handleObserverReleaseNotes(req, res), res);
+      return;
+    }
     if (pathname === "/update/apply") {
       runAsyncHandler(handleUpdateApply(req, res), res);
       return;
@@ -84335,6 +84511,22 @@ function createConsoleServer(deps = {}) {
   function handleObserverApiCatalog(_req, res) {
     writeJson(res, 200, { version: version22, routes: buildApiCatalog() });
   }
+  async function handleObserverReleaseNotes(req, res) {
+    if (req.method !== "GET") {
+      writeJson(res, 405, { error: "Method not allowed" });
+      return;
+    }
+    try {
+      const force = readUrl(req).searchParams.get("force") === "true";
+      writeJson(res, 200, await releaseNotes.refresh({ force }));
+    } catch (error512) {
+      if (error512 instanceof ConsoleReleaseNotesUnavailableError) {
+        writeJson(res, 503, { error: "release_notes_unavailable" });
+        return;
+      }
+      throw error512;
+    }
+  }
   async function handleUpdateApply(req, res) {
     if (req.method !== "POST") {
       writeJson(res, 405, { error: "Method not allowed" });