gloomberb 0.18.2 → 0.18.3

package/src/updater/index.ts

@@ -1,5 +1,13 @@
 import type { UpdateChannel } from "../types/config";
+import { reportUpdateFailure, type UpdateInstallKind } from "../telemetry/update-failures";
 import { compareSemver, isPrereleaseVersion } from "../utils/semver";
+import {
+  classifyUpdateError,
+  httpStatusFailureCode,
+  type UpdateFailure,
+  type UpdateFailureCode,
+  type UpdateFailurePhase,
+} from "./failure";
 import {
   GITHUB_LATEST_RELEASE_API_URL,
   GITHUB_RELEASES_API_URL,
@@ -49,6 +57,8 @@ export interface UpdateProgress {
   message?: string;
   /** With `ready`: this host can apply the update and relaunch on request. */
   canRestart?: boolean;
+  /** With `error`: the step that failed and why, which the header says in a few words. */
+  failure?: UpdateFailure;
 }
 
 export type UpdateAction =
@@ -68,7 +78,7 @@ export type UpdateCheckResult =
   /** `notice`: why a newer-looking state is not an update, such as a nightly build waiting for a stable release. */
   | { kind: "current"; notice?: string }
   | { kind: "disabled" }
-  | { kind: "error"; error: string };
+  | { kind: "error"; error: string; failure?: UpdateFailure };
 
 /**
  * On the stable channel a nightly build is never replaced by an older stable
@@ -302,6 +312,23 @@ export function canSelfUpdate(release: Pick<ReleaseInfo, "updateAction"> | null
   return release?.updateAction.kind === "self" || release?.updateAction.kind === "desktop";
 }
 
+/**
+ * Whether the install-update key has something to retry: a release this build
+ * can install itself whose last attempt failed. A fresh one downloads on its
+ * own, and a manual or managed one names its own command. (A downloaded
+ * desktop update has its own use of the key: restarting into it.)
+ */
+export function canRetryUpdate(state: {
+  updateAvailable: ReleaseInfo | null;
+  updateProgress: UpdateProgress | null;
+  updateCheckInProgress: boolean;
+}): boolean {
+  return !!state.updateAvailable
+    && state.updateProgress?.phase === "error"
+    && !state.updateCheckInProgress
+    && canSelfUpdate(state.updateAvailable);
+}
+
 /** A downloaded update this host can install and relaunch into when the user asks. */
 export function canRestartToApply(progress: UpdateProgress | null | undefined): boolean {
   return progress?.phase === "ready" && progress.canRestart === true;
@@ -344,6 +371,11 @@ export async function checkForUpdateDetailed(
     return { kind: "disabled" };
   }
   const nightly = channel === "nightly" && updateAction.kind === "self";
+  const failed = (error: string, code: UpdateFailureCode, targetVersion?: string): UpdateCheckResult => {
+    const failure: UpdateFailure = { phase: "check", code };
+    reportUpdateFailure(failure, { targetVersion, channel: nightly ? "nightly" : "stable" });
+    return { kind: "error", error, failure };
+  };
 
   let timeout: ReturnType<typeof setTimeout> | undefined;
   try {
@@ -356,7 +388,7 @@ export async function checkForUpdateDetailed(
     });
 
     if (!res.ok) {
-      return { kind: "error", error: `GitHub returned ${res.status}` };
+      return failed(`GitHub returned ${res.status}`, httpStatusFailureCode(res.status));
     }
 
     const payload = await res.json();
@@ -379,16 +411,10 @@ export async function checkForUpdateDetailed(
 
     const asset = resolveReleaseAsset(data.assets);
     if (!asset) {
-      return {
-        kind: "error",
-        error: `No compatible release asset found for ${getAssetBaseName()}`,
-      };
+      return failed(`No compatible release asset found for ${getAssetBaseName()}`, "no_build", version);
     }
     if (!asset.checksum) {
-      return {
-        kind: "error",
-        error: `Release asset ${asset.name} is missing a valid SHA-256 digest`,
-      };
+      return failed(`Release asset ${asset.name} is missing a valid SHA-256 digest`, "no_build", version);
     }
 
     return {
@@ -406,12 +432,10 @@ export async function checkForUpdateDetailed(
     };
   } catch (error: unknown) {
     if (error instanceof Error && error.name === "AbortError") {
-      return { kind: "error", error: "Update check timed out" };
+      return failed("Update check timed out", "timeout");
     }
-    return {
-      kind: "error",
-      error: error instanceof Error ? error.message : "Update check failed",
-    };
+    const code = classifyUpdateError(error);
+    return failed(error instanceof Error ? error.message : "Update check failed", code === "unknown" && error instanceof SyntaxError ? "bad_response" : code);
   } finally {
     if (timeout) clearTimeout(timeout);
   }
@@ -507,14 +531,20 @@ export async function performUpdate(
   }
 
   const checksum = /^[a-f\d]{64}$/i.exec(release.checksum ?? "")?.[0].toLowerCase();
+  const fail = (failure: UpdateFailure, error: string) => {
+    reportUpdateFailure(failure, { targetVersion: release.version, channel: release.channel });
+    onProgress({ phase: "error", error, failure });
+  };
   if (!checksum) {
-    onProgress({ phase: "error", error: "Self-update requires a valid SHA-256 checksum." });
+    fail({ phase: "verify", code: "no_build" }, "Self-update requires a valid SHA-256 checksum.");
     return;
   }
 
   const updatePath = execPath + ".update";
   const oldPath = execPath + ".old";
   let unlinkUpdatePath: ((path: string) => void) | null = null;
+  /** The step under way, which a thrown error is reported against. */
+  let phase: UpdateFailurePhase = "download";
 
   try {
     // Not import(): Bun folds even a specifier held in a variable and bundles
@@ -531,7 +561,7 @@ export async function performUpdate(
 
     const res = await fetch(release.downloadUrl);
     if (!res.ok || !res.body) {
-      throw new Error(`Download failed: ${res.status}`);
+      throw new UpdateStepError({ phase: "download", code: httpStatusFailureCode(res.status) }, `Download failed: ${res.status}`);
     }
 
     const contentLength = Number(res.headers.get("content-length") || 0);
@@ -540,7 +570,18 @@ export async function performUpdate(
     let received = 0;
 
     while (true) {
-      const { done, value } = await reader.read();
+      let chunk: Awaited<ReturnType<typeof reader.read>>;
+      try {
+        chunk = await reader.read();
+      } catch (error) {
+        // The connection broke partway: whatever it says, the file is incomplete.
+        const code = classifyUpdateError(error);
+        throw new UpdateStepError(
+          { phase: "download", code: code === "timeout" ? code : "interrupted" },
+          error instanceof Error ? error.message : "Download interrupted",
+        );
+      }
+      const { done, value } = chunk;
       if (done) break;
       chunks.push(value);
       received += value.length;
@@ -551,7 +592,14 @@ export async function performUpdate(
         });
       }
     }
+    if (contentLength > 0 && received < contentLength) {
+      throw new UpdateStepError(
+        { phase: "download", code: "interrupted" },
+        `Download stopped at ${received} of ${contentLength} bytes`,
+      );
+    }
 
+    phase = "verify";
     const downloaded = new Uint8Array(received);
     let offset = 0;
     for (const chunk of chunks) {
@@ -560,11 +608,12 @@ export async function performUpdate(
     }
     const actual = createHash("sha256").update(downloaded).digest("hex");
     if (actual !== checksum) {
-      throw new Error(`Checksum mismatch: expected ${checksum}, got ${actual}`);
+      throw new UpdateStepError({ phase: "verify", code: "corrupt" }, `Checksum mismatch: expected ${checksum}, got ${actual}`);
     }
     const nextBinary = release.compressed
       ? new Uint8Array(gunzipSync(downloaded))
       : downloaded;
+    phase = "apply";
     await Bun.write(updatePath, nextBinary);
     chmodSync(updatePath, 0o755);
 
@@ -600,9 +649,24 @@ export async function performUpdate(
     try {
       unlinkUpdatePath?.(updatePath);
     } catch { /* Intentional ignore: Remove a partial update download while the original failure is reported through update progress. */ }
-    onProgress({
-      phase: "error",
-      error: err instanceof Error ? err.message : "Update failed",
-    });
+    const failure = err instanceof UpdateStepError ? err.failure : { phase, code: classifyUpdateError(err) };
+    fail(failure, err instanceof Error ? err.message : "Update failed");
   }
 }
+
+/** A failed step whose code is known where it is thrown. */
+class UpdateStepError extends Error {
+  constructor(readonly failure: UpdateFailure, message: string) {
+    super(message);
+    this.name = "UpdateStepError";
+  }
+}
+
+/** How the running terminal app was installed, as update failure reports name it. */
+export function terminalInstallKind(action: UpdateAction | null = detectUpdateAction()): UpdateInstallKind {
+  if (!action) return "terminal-source";
+  if (action.kind === "self") return "terminal-binary";
+  if (action.kind === "managed") return "terminal-managed";
+  if (action.kind === "manual") return "terminal-package-manager";
+  return "unknown";
+}

package/src/utils/currency-pair.ts

@@ -84,3 +84,29 @@ export function looksLikeCurrencyPair(symbol: string): boolean {
   const halves = /^([A-Z]{3})[^A-Z0-9]?([A-Z]{3})(?:=X)?$/.exec(code)?.slice(1) ?? /^([A-Z]{3})=X$/.exec(code)?.slice(1) ?? [];
   return halves.some(isCurrencyCode);
 }
+
+/**
+ * Which currency of a pair markets quote it per: EUR, GBP, AUD and NZD go
+ * before the dollar, the dollar before CAD, CHF and the rest, and the yen goes
+ * last (EUR/USD, USD/CAD, USD/JPY, EUR/CAD, CAD/JPY).
+ */
+const PAIR_BASE_ORDER = ["EUR", "GBP", "AUD", "NZD", "USD", "CAD", "CHF"];
+
+function pairBaseRank(code: string): number {
+  const at = PAIR_BASE_ORDER.indexOf(code);
+  if (at >= 0) return at;
+  return code === "JPY" ? PAIR_BASE_ORDER.length + 1 : PAIR_BASE_ORDER.length;
+}
+
+/**
+ * A rate of `quote` per unit of `currency`, written the way markets quote
+ * the pair, as `fx` reads a pair: 0.0067 USD per JPY is USD/JPY 149.25, and
+ * 1.4 CAD per USD stays USD/CAD 1.4. Two codes of the same rank keep their
+ * order.
+ */
+export function quotedFxPair(currency: string, quote: string, rate: number): { pair: string; rate: number } {
+  const from = currency.trim().toUpperCase(), into = quote.trim().toUpperCase();
+  return pairBaseRank(into) < pairBaseRank(from)
+    ? { pair: `${into}/${from}`, rate: 1 / rate }
+    : { pair: `${from}/${into}`, rate };
+}

package/src/utils/sec.ts

@@ -163,6 +163,74 @@ export function noSecReportsNotice(listing: { symbol: string; exchange: string;
   return `${shortListingTitle(listing)} files no SEC reports.`;
 }
 
+/** The country of a venue abroad, ISO 3166 alpha-2, for the companies an SEC report may list there. */
+const VENUE_COUNTRY: Readonly<Record<string, string>> = {
+  TSX: "CA", TSXV: "CA", CSE: "CA", NEO: "CA",
+  LSE: "GB",
+  ASX: "AU", CXA: "AU", NZX: "NZ",
+  SWX: "CH",
+  XETRA: "DE", FWB2: "DE", EPA: "FR", AMS: "NL", BRU: "BE", LIS: "PT", BIT: "IT", MCE: "ES", ISE: "IE",
+  SFB: "SE", HEL: "FI", CPH: "DK", OSL: "NO", ICEX: "IS", WSE: "PL", PSE: "CZ", VIE: "AT", WBDM: "AT",
+  JPX: "JP", HKEX: "HK", KRX: "KR", KOSDAQ: "KR", TWSE: "TW", TPEX: "TW", SSE: "CN", SZSE: "CN",
+  NSE: "IN", BSE: "IN", SGX: "SG", SET: "TH",
+  BMV: "MX", B3: "BR", BYMA: "AR", JSE: "ZA", TASE: "IL", BIST: "TR", TADAWUL: "SA",
+};
+
+/** The European Economic Area, whose issuers report managers' dealings under the Market Abuse Regulation. */
+const EEA = new Set(["AT", "BE", "CZ", "DE", "DK", "ES", "FI", "FR", "IE", "IS", "IT", "NL", "NO", "PL", "PT", "SE"]);
+
+/** Insider reports outside the SEC by the name they go by, by the issuer's country. */
+const HOME_INSIDER_REPORTS: Readonly<Record<string, string>> = {
+  CA: "Canadian insider reports (SEDI)",
+  GB: "UK insider reports (PDMR notifications)",
+  AU: "Australian insider reports (Appendix 3Y)",
+};
+
+/** The country of a venue abroad that a company's insiders may report in (TSX is CA); null for a US venue or one not placed. */
+export function venueHomeCountry(exchange: string | null | undefined): string | null {
+  return VENUE_COUNTRY[canonicalExchange(exchange ?? "")] ?? null;
+}
+
+/** A country's English name ("Japan"), or null when the runtime has none. */
+function countryName(code: string): string | null {
+  try {
+    const name = new Intl.DisplayNames(["en"], { type: "region" }).of(code);
+    return name && name !== code ? name : null;
+  } catch {
+    // Intentional ignore: a runtime without region names leaves the home market unnamed.
+    return null;
+  }
+}
+
+/**
+ * What a company from abroad's insiders report at home, which Form 4 data
+ * does not cover: "Canadian insider reports (SEDI) not covered." Where home
+ * is comes from the company's country (Gloom Cloud's issuer listings: RY in
+ * New York is Royal Bank of Canada), else its listing's venue abroad (RY:TSX).
+ * A foreign private issuer placed by neither gets its home market unnamed.
+ * Null for a US company, and for a US listing of a company that files as a
+ * domestic one, whose insiders file Form 4.
+ */
+export function homeInsiderReportsNote({ country, exchange, foreignPrivateIssuer = false }: {
+  /** The company's country, ISO 3166 alpha-2, when known. */
+  country?: string | null;
+  /** The listing's venue. */
+  exchange?: string | null;
+  foreignPrivateIssuer?: boolean;
+}): string | null {
+  const venueHome = venueHomeCountry(exchange) ?? "";
+  if (!venueHome && !foreignPrivateIssuer) return null;
+  // ZZ is the service's own word for a country it does not know.
+  const given = normalize(country ?? "");
+  const home = (given !== "ZZ" ? given : "") || venueHome;
+  if (home === "US") return null;
+  if (!home) return foreignPrivateIssuer ? "Home-market insider reports not covered." : null;
+  const named = HOME_INSIDER_REPORTS[home] ?? (EEA.has(home) ? "European insider reports (MAR managers' transactions)" : null);
+  if (named) return `${named} not covered.`;
+  const place = countryName(home);
+  return place ? `Insider reports filed in ${place} not covered.` : "Home-market insider reports not covered.";
+}
+
 /**
  * The key an issuer read is cached and deduplicated under: the ticker as given
  * for a US listing or a symbol with no venue, SYMBOL:VENUE for a listing