@fire-spark/cli 0.13.2 → 0.14.0

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

@@ -0,0 +1,410 @@
+import type { Copy } from "../../../core/i18n";
+import { fromLive, isOutcome, isRecord, openLive, prepare } from "./flow";
+import { queryOf, readPage, say, textOf, 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}."
+  ),
+  list: line(
+    "El menú no es una lista.",
+    "The menu is not a list.",
+    "O cardápio não é uma lista."
+  ),
+  need: line(
+    "{id} se omite: falta {field}.",
+    "{id} is skipped: {field} is missing.",
+    "{id} é omitido: falta {field}."
+  ),
+  shape: line(
+    "La respuesta no tiene la forma esperada.",
+    "The response does not have the expected shape.",
+    "A resposta não tem a forma esperada."
+  ),
+  page: line(
+    "La página publicada respondió {status}.",
+    "The published page returned {status}.",
+    "A página publicada respondeu {status}."
+  ),
+  biometric: line(
+    "El repo del canal no importa el desbloqueo biométrico.",
+    "The channel repo does not import biometric unlock.",
+    "O repo do canal não importa o desbloqueio biométrico."
+  ),
+  handoff: line(
+    "La página publicada no muestra un enlace de handoff.",
+    "The published page does not show a handoff link.",
+    "A página publicada não mostra um link de handoff."
+  ),
+  guard: line(
+    "Una orden sin un token válido no respondió 401.",
+    "An order request without a valid token did not return 401.",
+    "Um pedido sem um token válido não respondeu 401."
+  ),
+  orders: line(
+    "El listado de órdenes del cliente identificado no es una lista.",
+    "The identified customer's order list is not a list.",
+    "A lista de pedidos do cliente identificado não é uma lista."
+  )
+};
+
+const LIVE = [
+  "api_url",
+  "channel_id",
+  "FIRESPARK_DOCTOR_CUSTOMER_EMAIL",
+  "FIRESPARK_DOCTOR_CUSTOMER_PASSWORD",
+  "FIRESPARK_DOCTOR_FIREBASE_API_KEY"
+] as const;
+
+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 missingEnv = (ctx: RunCtx, id: string, field: string) => {
+  return say(ctx.locale, "skip", COPY.need, { id, field });
+};
+
+const firstGap = (env: NodeJS.ProcessEnv, fields: readonly string[]) => {
+  for (const field of fields) {
+    if (!textOf(env[field])) return field;
+  }
+  return "";
+};
+
+const DEVICE = [
+  "FIRESPARK_DOCTOR_DEVICE_UID",
+  "FIRESPARK_DOCTOR_DEVICE_SECRET"
+] as const;
+
+const menusOf = async (ctx: RunCtx, channel: YamlChannel) => {
+  const live = openLive(ctx, channel);
+  const path = queryOf("/menus", { channel_id: textOf(channel.channel_id) });
+  const codes = [200];
+  const args = ["menus", "GET", path, codes] as const;
+  const step = await live.storefront<unknown>(...args);
+  if (!step.ok) return fromLive(ctx.locale, step.result);
+  if (!Array.isArray(step.value)) return say(ctx.locale, "fail", COPY.list);
+  return { live };
+};
+
+const ordersUrl = (channel: YamlChannel) => {
+  const root = textOf(channel.api_url).replace(/\/$/, "");
+  return `${root}/api/storefront/v1/orders`;
+};
+
+const statusOf = async (
+  url: string,
+  authorization?: string,
+  method = "GET",
+  body?: string
+) => {
+  const headers: Record<string, string> = {};
+  if (authorization) headers.authorization = authorization;
+  if (body !== undefined) headers["content-type"] = "application/json";
+  try {
+    const signal = AbortSignal.timeout(15000);
+    const response = await fetch(url, { method, headers, body, signal });
+    return response.status;
+  } catch {
+    return 0;
+  }
+};
+
+const pageOf = async (url: string) => {
+  try {
+    return await readPage(url);
+  } catch {
+    return { status: 0, body: "" };
+  }
+};
+
+const runLog02 = async (ctx: RunCtx): Promise<Outcome> => {
+  const skipped = applies(ctx, "LOG-02", new Set(["kiosk", "web", "app"]));
+  if (skipped) return skipped;
+  const ready = prepare(ctx, [...LIVE, "url"]);
+  if (isOutcome(ready)) return ready;
+  const loaded = await menusOf(ctx, ready);
+  if (isOutcome(loaded)) return loaded;
+  const codes = [200];
+  const args = ["customer", "GET", "/customers/me", codes] as const;
+  const step = await loaded.live.storefront<unknown>(...args);
+  if (!step.ok) return fromLive(ctx.locale, step.result);
+  if (!isRecord(step.value)) return say(ctx.locale, "fail", COPY.shape);
+  const email = step.value.email;
+  if (typeof email !== "string" || !email.includes("@")) {
+    return say(ctx.locale, "fail", COPY.shape);
+  }
+  const files = await readSources(ctx.cwd);
+  const google = files.find(file => file.body.includes("GoogleSignIn"));
+  if (
+    google &&
+    !google.body.includes("clientId") &&
+    !google.body.includes("webClientId")
+  ) {
+    return say(ctx.locale, "fail", COPY.shape);
+  }
+  return { status: "pass" };
+};
+
+const runLog05 = async (ctx: RunCtx): Promise<Outcome> => {
+  const skipped = applies(ctx, "LOG-05", new Set(["pos"]));
+  if (skipped) return skipped;
+  const files = await readSources(ctx.cwd);
+  const found = files.some(file => {
+    if (file.body.includes("expo-local-authentication")) return true;
+    return file.body.includes("LocalAuthentication");
+  });
+  if (!found) return say(ctx.locale, "fail", COPY.biometric);
+  return { status: "pass" };
+};
+
+const postJson = async (url: string, body: unknown) => {
+  const headers = { "content-type": "application/json" };
+  const payload = JSON.stringify(body);
+  const signal = AbortSignal.timeout(15000);
+  const init = { method: "POST", headers, body: payload, signal };
+  const response = await fetch(url, init);
+  const json = (await response.json()) as Record<string, unknown>;
+  return { status: response.status, json };
+};
+
+const guestMenus = async (ctx: RunCtx, channel: YamlChannel) => {
+  const auth = textOf(ctx.env.FIRESPARK_DOCTOR_FIREBASE_AUTH_URL);
+  const key = textOf(ctx.env.FIRESPARK_DOCTOR_FIREBASE_API_KEY);
+  if (!auth || !key) {
+    return missingEnv(ctx, "LOG-08", "FIRESPARK_DOCTOR_FIREBASE_AUTH_URL");
+  }
+  const api = textOf(channel.api_url).replace(/\/$/, "");
+  const signUp = `${auth.replace(/\/$/, "")}/v1/accounts:signUp?key=${key}`;
+  try {
+    const created = await postJson(signUp, { returnSecureToken: true });
+    const idToken = created.json.idToken;
+    if (created.status !== 200 || typeof idToken !== "string" || !idToken) {
+      return say(ctx.locale, "fail", COPY.shape);
+    }
+    const grant = "urn:ietf:params:oauth:grant-type:token-exchange";
+    const subject = "urn:ietf:params:oauth:token-type:id_token";
+    const exchange = {
+      grant_type: grant,
+      subject_token: idToken,
+      subject_token_type: subject
+    };
+    const exchangeUrl = `${api}/api/storefront/v1/oauth/exchange`;
+    const traded = await postJson(exchangeUrl, exchange);
+    const bag = traded.json.data;
+    const nested = isRecord(bag) ? bag.access_token : undefined;
+    const token = traded.json.access_token ?? nested;
+    if (traded.status !== 200 || typeof token !== "string" || !token) {
+      return say(ctx.locale, "fail", COPY.shape);
+    }
+    const channelId = textOf(channel.channel_id);
+    const menus = `${api}/api/storefront/v1/menus?channel_id=${channelId}`;
+    const header = `Bearer ${token}`;
+    const status = await statusOf(menus, header);
+    if (status !== 200) return say(ctx.locale, "fail", COPY.guard);
+    return { status: "pass" as const };
+  } catch {
+    return say(ctx.locale, "fail", COPY.shape);
+  }
+};
+
+const runLog08 = async (ctx: RunCtx): Promise<Outcome> => {
+  const skipped = applies(ctx, "LOG-08", new Set(["kiosk", "web", "app"]));
+  if (skipped) return skipped;
+  const ready = prepare(ctx, LIVE);
+  if (isOutcome(ready)) return ready;
+  const guest = await guestMenus(ctx, ready);
+  if (guest.status !== "pass") return guest;
+  const denied = await statusOf(ordersUrl(ready));
+  if (denied !== 401) return say(ctx.locale, "fail", COPY.guard);
+  return { status: "pass" };
+};
+
+const runLog09 = async (ctx: RunCtx): Promise<Outcome> => {
+  const skipped = applies(ctx, "LOG-09", new Set(["web", "app"]));
+  if (skipped) return skipped;
+  const ready = prepare(ctx, [...LIVE, "url"]);
+  if (isOutcome(ready)) return ready;
+  const page = await pageOf(textOf(ready.url));
+  if (page.status === 0 || page.status >= 400) {
+    return say(ctx.locale, "fail", COPY.page, { status: page.status });
+  }
+  const lower = page.body.toLowerCase();
+  const login = lower.includes("iniciar sesión") || lower.includes("login");
+  if (!login) return say(ctx.locale, "fail", COPY.guard);
+  const loaded = await menusOf(ctx, ready);
+  if (isOutcome(loaded)) return loaded;
+  const codes = [200];
+  const args = ["orders", "GET", "/orders", codes] as const;
+  const step = await loaded.live.storefront<unknown>(...args);
+  if (!step.ok) return fromLive(ctx.locale, step.result);
+  if (!Array.isArray(step.value)) return say(ctx.locale, "fail", COPY.orders);
+  return { status: "pass" };
+};
+
+const runLog10 = async (ctx: RunCtx): Promise<Outcome> => {
+  const allowed = new Set(["kiosk", "web", "app", "chat", "call-center"]);
+  const skipped = applies(ctx, "LOG-10", allowed);
+  if (skipped) return skipped;
+  const ready = prepare(ctx, [...LIVE, "url"]);
+  if (isOutcome(ready)) return ready;
+  const loaded = await menusOf(ctx, ready);
+  if (isOutcome(loaded)) return loaded;
+  const codes = [200];
+  const me = await loaded.live.storefront<unknown>(
+    "customer",
+    "GET",
+    "/customers/me",
+    codes
+  );
+  if (!me.ok) return fromLive(ctx.locale, me.result);
+  const root = textOf(ready.url).replace(/\/$/, "");
+  const cleared = await statusOf(
+    `${root}/api/auth/session`,
+    undefined,
+    "DELETE"
+  );
+  if (cleared < 200 || cleared >= 300)
+    return say(ctx.locale, "fail", COPY.guard);
+  const denied = await statusOf(ordersUrl(ready));
+  if (denied !== 401) return say(ctx.locale, "fail", COPY.guard);
+  return { status: "pass" };
+};
+
+const runLog01 = async (ctx: RunCtx): Promise<Outcome> => {
+  const skipped = applies(ctx, "LOG-01", new Set(["dashboard"]));
+  if (skipped) return skipped;
+  const ready = prepare(ctx, LIVE);
+  if (isOutcome(ready)) return ready;
+  const denied = await statusOf(ordersUrl(ready));
+  if (denied !== 401) return say(ctx.locale, "fail", COPY.guard);
+  const loaded = await menusOf(ctx, ready);
+  if (isOutcome(loaded)) return loaded;
+  const codes = [200];
+  const args = ["orders", "GET", "/orders", codes] as const;
+  const step = await loaded.live.storefront<unknown>(...args);
+  if (!step.ok) return fromLive(ctx.locale, step.result);
+  const token = textOf(ctx.env.FIRESPARK_DOCTOR_READONLY_TOKEN);
+  if (!token) {
+    return missingEnv(ctx, "LOG-01", "FIRESPARK_DOCTOR_READONLY_TOKEN");
+  }
+  const header = `Bearer ${token}`;
+  const wrote = await statusOf(ordersUrl(ready), header, "POST", "{}");
+  if (wrote !== 401 && wrote !== 403) {
+    return say(ctx.locale, "fail", COPY.guard);
+  }
+  return { status: "pass" };
+};
+
+const runLog03 = async (ctx: RunCtx): Promise<Outcome> => {
+  const skipped = applies(ctx, "LOG-03", new Set(["kiosk", "dashboard"]));
+  if (skipped) return skipped;
+  const ready = prepare(ctx, LIVE);
+  if (isOutcome(ready)) return ready;
+  const field = firstGap(ctx.env, DEVICE);
+  if (field) return missingEnv(ctx, "LOG-03", field);
+  const live = openLive(ctx, ready);
+  const device_uid = textOf(ctx.env.FIRESPARK_DOCTOR_DEVICE_UID);
+  const device_secret = textOf(ctx.env.FIRESPARK_DOCTOR_DEVICE_SECRET);
+  const version = { app_version_code: 1, app_version_name: "doctor" };
+  const body = { device_uid, device_secret, ...version };
+  const codes = [200];
+  const args = ["kiosk-me", "POST", "/kiosk/devices/me", codes, body] as const;
+  const step = await live.probe(...args);
+  if (!step.ok) return fromLive(ctx.locale, step.result);
+  if (!isRecord(step.value.json)) return say(ctx.locale, "fail", COPY.shape);
+  return { status: "pass" };
+};
+
+const runLog04 = async (ctx: RunCtx): Promise<Outcome> => {
+  const skipped = applies(ctx, "LOG-04", new Set(["pos", "dashboard"]));
+  if (skipped) return skipped;
+  const ready = prepare(ctx, LIVE);
+  if (isOutcome(ready)) return ready;
+  const pinFields = [...DEVICE, "FIRESPARK_DOCTOR_OPERATOR_ID"] as const;
+  const more = [...pinFields, "FIRESPARK_DOCTOR_OPERATOR_PIN"] as const;
+  const field = firstGap(ctx.env, more);
+  if (field) return missingEnv(ctx, "LOG-04", field);
+  const live = openLive(ctx, ready);
+  const device_uid = textOf(ctx.env.FIRESPARK_DOCTOR_DEVICE_UID);
+  const device_secret = textOf(ctx.env.FIRESPARK_DOCTOR_DEVICE_SECRET);
+  const operator_id = textOf(ctx.env.FIRESPARK_DOCTOR_OPERATOR_ID);
+  const pin = textOf(ctx.env.FIRESPARK_DOCTOR_OPERATOR_PIN);
+  const body = { device_uid, device_secret, operator_id, pin };
+  const codes = [200];
+  const path = "/pos/operators/verify";
+  const args = ["pin", "POST", path, codes, body] as const;
+  const step = await live.storefront<unknown>(...args);
+  if (!step.ok) return fromLive(ctx.locale, step.result);
+  if (!isRecord(step.value)) return say(ctx.locale, "fail", COPY.shape);
+  return { status: "pass" };
+};
+
+const runLog06 = async (ctx: RunCtx): Promise<Outcome> => {
+  const allowed = new Set(["call-center", "dashboard"]);
+  const skipped = applies(ctx, "LOG-06", allowed);
+  if (skipped) return skipped;
+  const ready = prepare(ctx, LIVE);
+  if (isOutcome(ready)) return ready;
+  const subject = textOf(ctx.env.FIRESPARK_DOCTOR_HANDOFF_TOKEN);
+  if (!subject)
+    return missingEnv(ctx, "LOG-06", "FIRESPARK_DOCTOR_HANDOFF_TOKEN");
+  const live = openLive(ctx, ready);
+  const channelId = textOf(ready.channel_id);
+  const body = { channel_id: channelId, subject_token: subject };
+  const path = "/call-center/sessions";
+  const createdCodes = [200, 201];
+  const step = await live.probe("agent", "POST", path, createdCodes, body);
+  if (!step.ok) return fromLive(ctx.locale, step.result);
+  const meCodes = [200];
+  const me = await live.probe("agent", "GET", "/call-center/me", meCodes);
+  if (!me.ok) return fromLive(ctx.locale, me.result);
+  const bad = { channel_id: channelId, subject_token: "doctor-invalid" };
+  const deniedCodes = [401, 403];
+  const denied = await live.probe("agent", "POST", path, deniedCodes, bad);
+  if (!denied.ok) return fromLive(ctx.locale, denied.result);
+  return { status: "pass" };
+};
+
+const runLog07 = async (ctx: RunCtx): Promise<Outcome> => {
+  const skipped = applies(ctx, "LOG-07", new Set(["chat"]));
+  if (skipped) return skipped;
+  const ready = prepare(ctx, ["url"]);
+  if (isOutcome(ready)) return ready;
+  const page = await pageOf(textOf(ready.url));
+  if (page.status === 0 || page.status >= 400) {
+    return say(ctx.locale, "fail", COPY.page, { status: page.status });
+  }
+  if (!page.body.toLowerCase().includes("handoff")) {
+    return say(ctx.locale, "fail", COPY.handoff);
+  }
+  const field = "FIRESPARK_DOCTOR_HANDOFF_TOKEN";
+  if (!textOf(ctx.env[field])) return missingEnv(ctx, "LOG-07", field);
+  return { status: "pass" };
+};
+
+export const LOG_BINDINGS: Record<string, CheckBinding> = {
+  "LOG-01": withSafeFix(runLog01),
+  "LOG-02": withSafeFix(runLog02),
+  "LOG-03": withSafeFix(runLog03),
+  "LOG-04": withSafeFix(runLog04),
+  "LOG-05": withSafeFix(runLog05),
+  "LOG-06": withSafeFix(runLog06),
+  "LOG-07": withSafeFix(runLog07),
+  "LOG-08": withSafeFix(runLog08),
+  "LOG-09": withSafeFix(runLog09),
+  "LOG-10": withSafeFix(runLog10)
+};