@fire-spark/cli 0.13.2 → 0.14.0

package/src/commands/doctor/client/store.flow.ts

@@ -0,0 +1,577 @@
+import { Big } from "big.js";
+
+import type { Copy } from "../../../core/i18n";
+import { fromLive, isOutcome, isRecord, openLive, prepare } from "./flow";
+import { say, textOf, trpcCall, withSafeFix } from "./flow";
+import { readSources } from "./repo.scan";
+import type { CheckBinding, Outcome, RunCtx } from "./runner";
+import type { YamlChannel } from "./yaml";
+
+const line = (es: string, en: string, pt: string): Copy => {
+  return { "es-EC": es, "en-US": en, "pt-BR": pt };
+};
+
+const COPY = {
+  channel: line(
+    "{id} no aplica al canal {template}.",
+    "{id} does not apply to the {template} channel.",
+    "{id} não se aplica ao canal {template}."
+  ),
+  hours: line(
+    "AVA-01 se omite: preferences no trae availability.",
+    "AVA-01 is skipped: preferences has no availability.",
+    "AVA-01 é omitido: preferences não traz availability."
+  ),
+  need: line(
+    "{id} se omite: falta {field}.",
+    "{id} is skipped: {field} is missing.",
+    "{id} é omitido: falta {field}."
+  ),
+  checkout: line(
+    "AVA-03 se omite: preferences no trae shipping ni billing.",
+    "AVA-03 is skipped: preferences has no shipping or billing.",
+    "AVA-03 é omitido: preferences não traz shipping nem billing."
+  ),
+  fees: line(
+    "AVA-04 se omite: no hay reglas de fee para calcular.",
+    "AVA-04 is skipped: there are no fee rules to calculate.",
+    "AVA-04 é omitido: não há regras de fee para calcular."
+  ),
+  closed: line(
+    "AVA-05 se omite: la regla de no disponible no está activa.",
+    "AVA-05 is skipped: the unavailable rule is not active.",
+    "AVA-05 é omitido: a regra de indisponível não está ativa."
+  ),
+  version: line(
+    "AVA-06 se omite: este canal no publicó min_version.",
+    "AVA-06 is skipped: this channel did not publish min_version.",
+    "AVA-06 é omitido: este canal não publicou min_version."
+  ),
+  outside: line(
+    "AVA-02 el punto está fuera de las coverage zones.",
+    "AVA-02 the point is outside the coverage zones.",
+    "AVA-02 o ponto está fora das coverage zones."
+  ),
+  drift: line(
+    "{id} el menú cambió entre dos lecturas.",
+    "{id} the menu changed between two reads.",
+    "{id} o cardápio mudou entre duas leituras."
+  ),
+  command: line(
+    "{id} el comando {type} respondió {status}.",
+    "{id} command {type} responded {status}.",
+    "{id} o comando {type} respondeu {status}."
+  ),
+  named: line(
+    "{id} solo corre cuando lo nombras. No mandé el comando.",
+    "{id} runs only when you name it. The command was not sent.",
+    "{id} só roda quando você o nomeia. O comando não foi enviado."
+  ),
+  fee: line(
+    "AVA-04 el fee calculado {expected} no coincide con el validate {actual}.",
+    "AVA-04 the computed fee {expected} does not match validate {actual}.",
+    "AVA-04 a taxa calculada {expected} não coincide com o validate {actual}."
+  ),
+  gate: line(
+    "AVA-05 la regla activa no trae título y descripción.",
+    "AVA-05 the active rule is missing a title and description.",
+    "AVA-05 a regra ativa não traz título e descrição."
+  ),
+  reset: line(
+    "RT-03 se omite: falta resetKioskCache en el repo del kiosk.",
+    "RT-03 is skipped: resetKioskCache is missing from the kiosk repo.",
+    "RT-03 é omitido: falta resetKioskCache no repo do kiosk."
+  ),
+  checklist: line(
+    "{id} el checklist no está completo: falta {field}.",
+    "{id} the checklist is incomplete: {field} is missing.",
+    "{id} o checklist não está completo: falta {field}."
+  )
+};
+
+const LIVE = [
+  "api_url",
+  "channel_id",
+  "FIRESPARK_DOCTOR_CUSTOMER_EMAIL",
+  "FIRESPARK_DOCTOR_CUSTOMER_PASSWORD",
+  "FIRESPARK_DOCTOR_FIREBASE_API_KEY"
+] as const;
+
+const BASE = "10.00";
+
+const applies = (ctx: RunCtx, id: string, allowed: ReadonlySet<string>) => {
+  const ready = prepare(ctx, ["channel_id"]);
+  if (isOutcome(ready)) return ready;
+  const template = textOf(ready.template);
+  if (allowed.has(template)) return null;
+  return say(ctx.locale, "skip", COPY.channel, { id, template });
+};
+
+const need = (ctx: RunCtx, id: string, field: string) => {
+  return say(ctx.locale, "skip", COPY.need, { id, field });
+};
+
+const finite = (value: unknown) => {
+  const number = Number(value);
+  return Number.isFinite(number) ? number : null;
+};
+
+const haversine = (lat1: number, lng1: number, lat2: number, lng2: number) => {
+  const radius = 6371000;
+  const p1 = (lat1 * Math.PI) / 180;
+  const p2 = (lat2 * Math.PI) / 180;
+  const dLat = ((lat2 - lat1) * Math.PI) / 180;
+  const dLng = ((lng2 - lng1) * Math.PI) / 180;
+  const a = Math.sin(dLat / 2) ** 2;
+  const b = Math.cos(p1) * Math.cos(p2) * Math.sin(dLng / 2) ** 2;
+  return 2 * radius * Math.asin(Math.sqrt(a + b));
+};
+
+const insidePolygon = (
+  lat: number,
+  lng: number,
+  points: { lat: number; lng: number }[]
+) => {
+  let inside = false;
+  for (let i = 0, j = points.length - 1; i < points.length; j = i++) {
+    const yi = points[i]?.lat ?? 0;
+    const xi = points[i]?.lng ?? 0;
+    const yj = points[j]?.lat ?? 0;
+    const xj = points[j]?.lng ?? 0;
+    const crosses = yi > lat !== yj > lat;
+    const edge = ((xj - xi) * (lat - yi)) / (yj - yi) + xi;
+    if (crosses && lng < edge) inside = !inside;
+  }
+  return inside;
+};
+
+const zoneContains = (
+  lat: number,
+  lng: number,
+  zone: Record<string, unknown>
+) => {
+  if (zone.type === "RADIUS" && isRecord(zone.radius_info)) {
+    const zlat = finite(zone.radius_info.latitude);
+    const zlng = finite(zone.radius_info.longitude);
+    const meters = finite(zone.radius_info.radius);
+    if (zlat === null || zlng === null || meters === null) return null;
+    return haversine(lat, lng, zlat, zlng) <= meters;
+  }
+  if (zone.type !== "POLYGON" || !isRecord(zone.polygon_info)) return null;
+  const polygon = zone.polygon_info.polygon;
+  if (!Array.isArray(polygon) || polygon.length < 3) return null;
+  const points: { lat: number; lng: number }[] = [];
+  for (const point of polygon) {
+    if (!isRecord(point)) return null;
+    const plat = finite(point.latitude);
+    const plng = finite(point.longitude);
+    if (plat === null || plng === null) return null;
+    points.push({ lat: plat, lng: plng });
+  }
+  return insidePolygon(lat, lng, points);
+};
+
+const preferencesOf = async (ctx: RunCtx, channel: YamlChannel) => {
+  const live = openLive(ctx, channel);
+  const codes = [200];
+  const args = ["preferences", "GET", "/preferences", codes] as const;
+  const step = await live.storefront<unknown>(...args);
+  if (!step.ok) return fromLive(ctx.locale, step.result);
+  return step.value;
+};
+
+const availabilityOf = (value: unknown) => {
+  if (!isRecord(value) || !isRecord(value.availability)) return null;
+  return value.availability;
+};
+
+const runAva01 = async (ctx: RunCtx): Promise<Outcome> => {
+  const allowed = new Set([
+    "kiosk",
+    "web",
+    "app",
+    "chat",
+    "call-center",
+    "dashboard"
+  ]);
+  const skipped = applies(ctx, "AVA-01", allowed);
+  if (skipped) return skipped;
+  if (!ctx.named.has("AVA-01")) return need(ctx, "AVA-01", "named");
+  const ready = prepare(ctx, LIVE);
+  if (isOutcome(ready)) return ready;
+  const prefs = await preferencesOf(ctx, ready);
+  if (isOutcome(prefs)) return prefs;
+  const availability = availabilityOf(prefs);
+  if (!availability) return need(ctx, "AVA-01", "preferences.availability");
+  const cookie = textOf(ctx.env.FIRESPARK_DOCTOR_DASHBOARD_COOKIE);
+  if (!cookie) return need(ctx, "AVA-01", "FIRESPARK_DOCTOR_DASHBOARD_COOKIE");
+  const dash = textOf(ready.dashboard_url);
+  if (!dash) return need(ctx, "AVA-01", "dashboard_url");
+  const merchant = textOf(ready.merchant_id);
+  if (!merchant) return need(ctx, "AVA-01", "merchant_id");
+  const env = textOf(ready.env);
+  if (!env) return need(ctx, "AVA-01", "env");
+  let current = "AVAILABLE";
+  if (availability.status === "UNAVAILABLE") current = "UNAVAILABLE";
+  const next = current === "AVAILABLE" ? "UNAVAILABLE" : "AVAILABLE";
+  const input = {
+    merchant_id: merchant,
+    env,
+    uid: textOf(ready.channel_id),
+    availability: { status: next }
+  };
+  const proc = "channels.updateAvailability";
+  const wrote = await trpcCall(dash, cookie, proc, input);
+  if (wrote.status < 200 || wrote.status >= 300) {
+    return say(ctx.locale, "fail", COPY.command, {
+      id: "AVA-01",
+      type: "availability.changed",
+      status: wrote.status
+    });
+  }
+  const again = await preferencesOf(ctx, ready);
+  if (isOutcome(again)) return again;
+  const seen = availabilityOf(again);
+  const restore = {
+    merchant_id: merchant,
+    env,
+    uid: textOf(ready.channel_id),
+    availability: { status: current }
+  };
+  await trpcCall(dash, cookie, "channels.updateAvailability", restore);
+  if (!seen || seen.status !== next) {
+    return say(ctx.locale, "fail", COPY.command, {
+      id: "AVA-01",
+      type: "availability.changed",
+      status: 200
+    });
+  }
+  return { status: "pass" };
+};
+
+const MODES = new Set(["required", "optional", "hidden"]);
+
+const fieldModes = (value: unknown) => {
+  if (!isRecord(value) || !isRecord(value.fields)) return null;
+  const modes = Object.values(value.fields);
+  if (modes.length === 0) return null;
+  const ok = modes.every(mode => typeof mode === "string" && MODES.has(mode));
+  return ok ? modes : null;
+};
+
+const runAva03 = async (ctx: RunCtx): Promise<Outcome> => {
+  const allowed = new Set(["kiosk", "web", "app", "chat", "call-center"]);
+  const skipped = applies(ctx, "AVA-03", allowed);
+  if (skipped) return skipped;
+  const ready = prepare(ctx, LIVE);
+  if (isOutcome(ready)) return ready;
+  const prefs = await preferencesOf(ctx, ready);
+  if (isOutcome(prefs)) return prefs;
+  if (!isRecord(prefs) || !isRecord(prefs.checkout)) {
+    return say(ctx.locale, "skip", COPY.checkout);
+  }
+  const shipping = fieldModes(prefs.checkout.shipping);
+  if (!shipping) return need(ctx, "AVA-03", "checkout.shipping.fields");
+  const billing = fieldModes(prefs.checkout.billing);
+  if (!billing) return need(ctx, "AVA-03", "checkout.billing.fields");
+  return { status: "pass" };
+};
+
+const feeRows = (value: unknown) => {
+  if (!isRecord(value) || !Array.isArray(value.fees)) return [];
+  return value.fees.filter(isRecord);
+};
+
+const percentageFee = (row: Record<string, unknown>) => {
+  const based = row.based_on;
+  if (based !== "ORDER_TOTAL" && based !== "ORDER_SUBTOTAL") return "";
+  if (typeof row.percentage !== "number") return "";
+  if (!Number.isFinite(row.percentage)) return "";
+  const due = new Big(BASE).times(row.percentage).div(100);
+  return due.toFixed(2);
+};
+
+const feeAmount = (value: unknown) => {
+  if (!isRecord(value)) return "";
+  const fees = value.fees;
+  const row = Array.isArray(fees) ? fees.find(isRecord) : undefined;
+  if (!row) return "";
+  const amount = row.amount;
+  if (typeof amount === "number" && Number.isFinite(amount)) {
+    return new Big(String(amount)).toFixed(2);
+  }
+  if (typeof amount === "string" && amount.trim()) {
+    try {
+      return new Big(amount).toFixed(2);
+    } catch {
+      return "";
+    }
+  }
+  return "";
+};
+
+const runAva04 = async (ctx: RunCtx): Promise<Outcome> => {
+  const allowed = new Set([
+    "kiosk",
+    "web",
+    "app",
+    "chat",
+    "call-center",
+    "dashboard"
+  ]);
+  const skipped = applies(ctx, "AVA-04", allowed);
+  if (skipped) return skipped;
+  const ready = prepare(ctx, LIVE);
+  if (isOutcome(ready)) return ready;
+  const prefs = await preferencesOf(ctx, ready);
+  if (isOutcome(prefs)) return prefs;
+  const rows = feeRows(prefs);
+  const expected = rows.map(percentageFee).find(Boolean) ?? "";
+  const fixed = rows.find(row => {
+    return row.based_on === "FIXED" && typeof row.amount === "number";
+  });
+  const fixedDue = fixed ? new Big(String(fixed.amount)).toFixed(2) : "";
+  const due = expected || fixedDue;
+  if (!due) return need(ctx, "AVA-04", "fees.based_on");
+  const live = openLive(ctx, ready);
+  const body = { subtotal: BASE };
+  const codes = [200];
+  const args = ["fees", "POST", "/orders/validate", codes, body] as const;
+  const step = await live.storefront<unknown>(...args);
+  if (!step.ok) return fromLive(ctx.locale, step.result);
+  const actual = feeAmount(step.value);
+  if (!actual) return need(ctx, "AVA-04", "orders.validate.fees");
+  if (actual !== due) {
+    return say(ctx.locale, "fail", COPY.fee, { expected: due, actual });
+  }
+  return { status: "pass" };
+};
+
+const runAva05 = async (ctx: RunCtx): Promise<Outcome> => {
+  const allowed = new Set([
+    "kiosk",
+    "web",
+    "app",
+    "chat",
+    "call-center",
+    "dashboard"
+  ]);
+  const skipped = applies(ctx, "AVA-05", allowed);
+  if (skipped) return skipped;
+  const ready = prepare(ctx, LIVE);
+  if (isOutcome(ready)) return ready;
+  const prefs = await preferencesOf(ctx, ready);
+  if (isOutcome(prefs)) return prefs;
+  const availability = availabilityOf(prefs);
+  if (!availability || availability.status !== "UNAVAILABLE") {
+    return say(ctx.locale, "skip", COPY.closed);
+  }
+  const rule = availability.rule;
+  if (!isRecord(rule)) return say(ctx.locale, "fail", COPY.gate);
+  const title = typeof rule.title === "string" ? rule.title.trim() : "";
+  const body = rule.description ?? rule.body;
+  const text = typeof body === "string" ? body.trim() : "";
+  if (!title || !text) return say(ctx.locale, "fail", COPY.gate);
+  return { status: "pass" };
+};
+
+const runAva06 = async (ctx: RunCtx): Promise<Outcome> => {
+  const allowed = new Set(["kiosk", "app", "dashboard"]);
+  const skipped = applies(ctx, "AVA-06", allowed);
+  if (skipped) return skipped;
+  const ready = prepare(ctx, LIVE);
+  if (isOutcome(ready)) return ready;
+  const prefs = await preferencesOf(ctx, ready);
+  if (isOutcome(prefs)) return prefs;
+  if (!isRecord(prefs) || !isRecord(prefs.release)) {
+    return need(ctx, "AVA-06", "release.min_version");
+  }
+  const min = prefs.release.min_version;
+  if (typeof min !== "string" || !min.trim()) {
+    return need(ctx, "AVA-06", "release.min_version");
+  }
+  const installed = textOf(ready.template_version);
+  if (!installed) return need(ctx, "AVA-06", "template_version");
+  if (min <= installed) return { status: "pass" };
+  return need(ctx, "AVA-06", "update gate");
+};
+
+const storeOf = async (ctx: RunCtx, channel: YamlChannel) => {
+  const live = openLive(ctx, channel);
+  const id = textOf(channel.store_id);
+  const codes = [200];
+  const args = ["store", "GET", `/stores/${id}`, codes] as const;
+  const step = await live.storefront<unknown>(...args);
+  if (!step.ok) return fromLive(ctx.locale, step.result);
+  return step.value;
+};
+
+const runAva02 = async (ctx: RunCtx) => {
+  const allowed = new Set(["web", "app", "chat", "call-center", "dashboard"]);
+  const skipped = applies(ctx, "AVA-02", allowed);
+  if (skipped) return skipped;
+  const ready = prepare(ctx, [...LIVE, "store_id"]);
+  if (isOutcome(ready)) return ready;
+  const store = await storeOf(ctx, ready);
+  if (isOutcome(store)) return store;
+  const zones = isRecord(store) ? store.coverage_zones : undefined;
+  if (!Array.isArray(zones) || zones.length === 0) {
+    return need(ctx, "AVA-02", "stores.coverage_zones");
+  }
+  const lat = textOf(ctx.env.FIRESPARK_DOCTOR_LATITUDE);
+  const lng = textOf(ctx.env.FIRESPARK_DOCTOR_LONGITUDE);
+  if (!lat) return need(ctx, "AVA-02", "FIRESPARK_DOCTOR_LATITUDE");
+  if (!lng) return need(ctx, "AVA-02", "FIRESPARK_DOCTOR_LONGITUDE");
+  if (!Number.isFinite(Number(lat)) || !Number.isFinite(Number(lng))) {
+    return need(ctx, "AVA-02", "FIRESPARK_DOCTOR_LATITUDE");
+  }
+  let evaluated = false;
+  for (const zone of zones) {
+    if (!isRecord(zone)) continue;
+    const hit = zoneContains(Number(lat), Number(lng), zone);
+    if (hit === null) continue;
+    evaluated = true;
+    if (hit) return { status: "pass" as const };
+  }
+  if (!evaluated) return need(ctx, "AVA-02", "coverage_zones.radius_info");
+  return say(ctx.locale, "fail", COPY.outside);
+};
+
+const overrideRead = async (ctx: RunCtx, id: string) => {
+  const skipped = applies(ctx, id, new Set(["dashboard"]));
+  if (skipped) return skipped;
+  const ready = prepare(ctx, LIVE);
+  if (isOutcome(ready)) return ready;
+  const cookie = textOf(ctx.env.FIRESPARK_DOCTOR_DASHBOARD_COOKIE);
+  if (!cookie) return need(ctx, id, "FIRESPARK_DOCTOR_DASHBOARD_COOKIE");
+  const dash = textOf(ready.dashboard_url);
+  if (!dash) return need(ctx, id, "dashboard_url");
+  const merchant = textOf(ready.merchant_id);
+  if (!merchant) return need(ctx, id, "merchant_id");
+  const env = textOf(ready.env);
+  if (!env) return need(ctx, id, "env");
+  const input = {
+    merchant_id: merchant,
+    env,
+    channel_id: textOf(ready.channel_id),
+    store_id: textOf(ready.store_id),
+    fulfillment_id: textOf(ready.fulfillment_id)
+  };
+  const proc = "menusOverrides.selectForScope";
+  const step = await trpcCall(dash, cookie, proc, input);
+  if (step.status < 200 || step.status >= 300) {
+    return say(ctx.locale, "fail", COPY.command, {
+      id,
+      type: "menusOverrides.selectForScope",
+      status: step.status
+    });
+  }
+  return { status: "pass" as const, text: step.text };
+};
+
+const runOvr01 = async (ctx: RunCtx) => {
+  const read = await overrideRead(ctx, "OVR-01");
+  if (!read || !("text" in read)) return read;
+  const ops = ["REORDER", "DELETE", "INSERT", "UPDATE"];
+  const found = ops.some(op => read.text.includes(op));
+  if (!found) return need(ctx, "OVR-01", "menus_overrides");
+  return { status: "pass" as const };
+};
+
+const runOvr02 = async (ctx: RunCtx) => {
+  if (!ctx.named.has("OVR-02")) {
+    return say(ctx.locale, "skip", COPY.named, { id: "OVR-02" });
+  }
+  const read = await overrideRead(ctx, "OVR-02");
+  if (!read || !("text" in read)) return read;
+  if (!read.text.includes("REORDER") && !read.text.includes("overrides")) {
+    return need(ctx, "OVR-02", "menus_overrides.preview");
+  }
+  return { status: "pass" as const };
+};
+
+const sendCommand = async (
+  ctx: RunCtx,
+  ready: YamlChannel,
+  id: string,
+  type: string
+) => {
+  if (!ctx.named.has(id)) return say(ctx.locale, "skip", COPY.named, { id });
+  const cookie = textOf(ctx.env.FIRESPARK_DOCTOR_DASHBOARD_COOKIE);
+  if (!cookie) return need(ctx, id, "FIRESPARK_DOCTOR_DASHBOARD_COOKIE");
+  const device = textOf(ctx.env.FIRESPARK_DOCTOR_DEVICE_ID);
+  if (!device) return need(ctx, id, "FIRESPARK_DOCTOR_DEVICE_ID");
+  const dash = textOf(ready.dashboard_url);
+  if (!dash) return need(ctx, id, "dashboard_url");
+  const merchant = textOf(ready.merchant_id);
+  if (!merchant) return need(ctx, id, "merchant_id");
+  const env = textOf(ready.env);
+  if (!env) return need(ctx, id, "env");
+  const input = { merchant_id: merchant, env, id: device, type };
+  const step = await trpcCall(dash, cookie, "kioskDevices.sendCommand", input);
+  if (step.status >= 400 || step.status === 0) {
+    return say(ctx.locale, "fail", COPY.command, {
+      id,
+      type,
+      status: step.status
+    });
+  }
+  return { status: "pass" as const };
+};
+
+const runCommand = (id: string, allowed: readonly string[], type: string) => {
+  return async (ctx: RunCtx) => {
+    const skipped = applies(ctx, id, new Set(allowed));
+    if (skipped) return skipped;
+    const ready = prepare(ctx, ["channel_id"]);
+    if (isOutcome(ready)) return ready;
+    return sendCommand(ctx, ready, id, type);
+  };
+};
+
+const runRt02 = runCommand("RT-02", ["kiosk", "dashboard"], "refresh_cache");
+
+const runRt03 = async (ctx: RunCtx): Promise<Outcome> => {
+  const skipped = applies(ctx, "RT-03", new Set(["kiosk"]));
+  if (skipped) return skipped;
+  if (!ctx.named.has("RT-03")) {
+    return say(ctx.locale, "skip", COPY.named, { id: "RT-03" });
+  }
+  const files = await readSources(ctx.cwd);
+  const file = files.find(item => item.body.includes("resetKioskCache"));
+  if (!file) return say(ctx.locale, "skip", COPY.reset);
+  const clears = file.body.includes("clearImageCaches");
+  const queries = file.body.includes("removeQueries");
+  if (!clears || !queries) return say(ctx.locale, "fail", COPY.reset);
+  return { status: "pass" as const };
+};
+
+const runRt04 = runCommand("RT-04", ["kiosk", "dashboard"], "reload");
+
+const runRt05 = async (ctx: RunCtx) => {
+  const skipped = applies(ctx, "RT-05", new Set(["kiosk", "dashboard"]));
+  if (skipped) return skipped;
+  if (!ctx.named.has("RT-05")) {
+    return say(ctx.locale, "skip", COPY.named, { id: "RT-05" });
+  }
+  const ready = prepare(ctx, ["channel_id"]);
+  if (isOutcome(ready)) return ready;
+  const update = textOf(ctx.env.FIRESPARK_DOCTOR_OTA_UPDATE_ID);
+  if (!update) return need(ctx, "RT-05", "FIRESPARK_DOCTOR_OTA_UPDATE_ID");
+  return sendCommand(ctx, ready, "RT-05", "check_ota");
+};
+
+export const STORE_BINDINGS: Record<string, CheckBinding> = {
+  "AVA-01": withSafeFix(runAva01),
+  "AVA-02": withSafeFix(runAva02),
+  "AVA-03": withSafeFix(runAva03),
+  "AVA-04": withSafeFix(runAva04),
+  "AVA-05": withSafeFix(runAva05),
+  "AVA-06": withSafeFix(runAva06),
+  "OVR-01": withSafeFix(runOvr01),
+  "OVR-02": withSafeFix(runOvr02),
+  "RT-02": withSafeFix(runRt02),
+  "RT-03": withSafeFix(runRt03),
+  "RT-04": withSafeFix(runRt04),
+  "RT-05": withSafeFix(runRt05)
+};

package/src/commands/doctor/live/http.ts

@@ -4,7 +4,7 @@ export type FetchLike = (
 ) => Promise<Response>;
 
 export interface HttpRequest {
-  method: "GET" | "POST";
+  method: "GET" | "POST" | "PATCH" | "DELETE";
   url: string;
   token?: string;
   body?: unknown;
@@ -36,28 +36,21 @@ export const request = async (
   const headers: Record<string, string> = { accept: "application/json" };
   if (input.token) headers.authorization = `Bearer ${input.token}`;
   if (input.body !== undefined) headers["content-type"] = "application/json";
-  const body =
-    input.body === undefined ? undefined : JSON.stringify(input.body);
+  const raw = input.body;
+  const body = raw === undefined ? undefined : JSON.stringify(raw);
   const signal = AbortSignal.timeout(input.timeoutMs);
+  const init = { method: input.method, headers, body, signal };
   let response: Response;
   try {
-    response = await fetchImpl(input.url, {
-      method: input.method,
-      headers,
-      body,
-      signal
-    });
+    response = await fetchImpl(input.url, init);
   } catch (error) {
     const detail = error instanceof Error ? error.message : String(error);
     throw new NetworkError(detail);
   }
   const text = await response.text();
-  return {
-    status: response.status,
-    headers: response.headers,
-    json: parse(text),
-    text
-  };
+  const b1 = { status: response.status, headers: response.headers };
+  const b2 = { json: parse(text), text };
+  return { ...b1, ...b2 };
 };
 
 /** Short, single-line description of an error body for logs. */
@@ -65,9 +58,8 @@ export const errorDetail = (response: HttpResponse) => {
   const json = response.json as
     | { error?: unknown; message?: unknown; details?: unknown }
     | undefined;
-  const parts = [json?.error, json?.message].filter(
-    part => typeof part === "string"
-  );
+  const isText = (part: unknown) => typeof part === "string";
+  const parts = [json?.error, json?.message].filter(isText);
   const nested = (json?.error as { message?: unknown } | undefined)?.message;
   if (typeof nested === "string") parts.push(nested);
   if (json?.details !== undefined) parts.push(JSON.stringify(json.details));

package/src/commands/doctor/live/live.session.ts

@@ -45,11 +45,18 @@ type Step<T> =
 export interface LiveSession {
   storefront: <T>(
     hop: string,
-    method: "GET" | "POST",
+    method: "GET" | "POST" | "PATCH" | "DELETE",
     path: string,
     statuses: number[],
     body?: unknown
   ) => Promise<Step<T>>;
+  probe: (
+    hop: string,
+    method: "GET" | "POST" | "PATCH" | "DELETE",
+    path: string,
+    statuses: number[],
+    body?: unknown
+  ) => Promise<Step<HttpResponse>>;
   menus: () => Promise<Step<Menu[]>>;
   realtimeToken: () => Promise<Step<RealtimeToken>>;
 }
@@ -148,8 +155,8 @@ export const createLiveSession = (
       if (!step.ok) return step;
       const failed = expectAt("firebase-auth", step.value, [200], "POST", url);
       if (failed) return no(failed);
-      const token = (step.value.json as { idToken?: string } | undefined)
-        ?.idToken;
+      const json = step.value.json as { idToken?: string } | undefined;
+      const token = json?.idToken;
       if (!token) {
         const field = "idToken";
         const reason = fail("firebase-auth", REASONS.badShape, { field });
@@ -189,7 +196,7 @@ export const createLiveSession = (
 
   const raw = async (
     hop: string,
-    method: "GET" | "POST",
+    method: "GET" | "POST" | "PATCH" | "DELETE",
     path: string,
     statuses: number[],
     body?: unknown
@@ -206,7 +213,7 @@ export const createLiveSession = (
 
   const storefront = async <T>(
     hop: string,
-    method: "GET" | "POST",
+    method: "GET" | "POST" | "PATCH" | "DELETE",
     path: string,
     statuses: number[],
     body?: unknown
@@ -239,5 +246,5 @@ export const createLiveSession = (
     });
   };
 
-  return { storefront, menus, realtimeToken };
+  return { storefront, probe: raw, menus, realtimeToken };
 };