@fire-spark/cli 0.0.0-stage → 0.13.3

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

@@ -0,0 +1,312 @@
+import type { Copy } from "../../../core/i18n";
+import { fromLive, isOutcome, openLive, prepare } from "./flow";
+import { readPage, say, textOf, trpcCall, withSafeFix } from "./flow";
+import { readSources } from "./repo.scan";
+import type { CheckBinding, Outcome, RunCtx } from "./runner";
+
+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}."
+  ),
+  need: line(
+    "{id} se omite: falta {field}.",
+    "{id} is skipped: {field} is missing.",
+    "{id} é omitido: falta {field}."
+  ),
+  named: line(
+    "{id} solo corre cuando lo nombras. No cambié el equipo.",
+    "{id} runs only when you name it. The device was not changed.",
+    "{id} só roda quando você o nomeia. O equipamento não foi alterado."
+  ),
+  print: line(
+    "El repo del canal no llama a printReceipt.",
+    "The channel repo does not call printReceipt.",
+    "O repo do canal não chama printReceipt."
+  ),
+  page: line(
+    "La página pública del canal no respondió.",
+    "The channel public page did not respond.",
+    "A página pública do canal não respondeu."
+  ),
+  socket: line(
+    "RT-10 encontró un listener de realtime fuera de checkout u orden: {file}.",
+    "RT-10 found a realtime listener outside checkout or order: {file}.",
+    "RT-10 encontrou um listener de realtime fora do checkout ou do pedido: {file}."
+  ),
+  reboot: line(
+    "RT-07 kioskDevices.reboot respondió {status}.",
+    "RT-07 kioskDevices.reboot responded {status}.",
+    "RT-07 kioskDevices.reboot respondeu {status}."
+  )
+};
+
+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 LIVE = [
+  "api_url",
+  "channel_id",
+  "FIRESPARK_DOCTOR_CUSTOMER_EMAIL",
+  "FIRESPARK_DOCTOR_CUSTOMER_PASSWORD",
+  "FIRESPARK_DOCTOR_FIREBASE_API_KEY"
+] as const;
+
+const need = (ctx: RunCtx, id: string, field: string) => {
+  return say(ctx.locale, "skip", COPY.need, { id, field });
+};
+
+const deviceGap = (env: NodeJS.ProcessEnv) => {
+  if (!textOf(env.FIRESPARK_DOCTOR_DEVICE_UID)) {
+    return "FIRESPARK_DOCTOR_DEVICE_UID";
+  }
+  if (!textOf(env.FIRESPARK_DOCTOR_DEVICE_SECRET)) {
+    return "FIRESPARK_DOCTOR_DEVICE_SECRET";
+  }
+  return "";
+};
+
+const heartbeat = async (ctx: RunCtx, id: string, path: string) => {
+  const ready = prepare(ctx, LIVE);
+  if (isOutcome(ready)) return ready;
+  const field = deviceGap(ctx.env);
+  if (field) return need(ctx, id, 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 = ["device", "POST", path, codes, body] as const;
+  const step = await live.probe(...args);
+  if (!step.ok) return fromLive(ctx.locale, step.result);
+  return { status: "pass" as const };
+};
+
+const scoped = (rel: string) => {
+  const path = rel.toLowerCase();
+  if (path.includes("checkout")) return true;
+  if (path.includes("order")) return true;
+  return false;
+};
+
+const listener = (body: string) => {
+  if (body.includes("@fire-spark/realtime")) return true;
+  if (body.includes("new WebSocket")) return true;
+  return false;
+};
+
+const runRt10 = async (ctx: RunCtx): Promise<Outcome> => {
+  const allowed = new Set(["web", "app", "chat", "call-center"]);
+  const skipped = applies(ctx, "RT-10", allowed);
+  if (skipped) return skipped;
+  const files = await readSources(ctx.cwd);
+  const found = files.find(file => !scoped(file.rel) && listener(file.body));
+  if (found) return say(ctx.locale, "fail", COPY.socket, { file: found.rel });
+  return { status: "pass" };
+};
+
+const runRt06 = async (ctx: RunCtx): Promise<Outcome> => {
+  const skipped = applies(ctx, "RT-06", new Set(["kiosk", "dashboard"]));
+  if (skipped) return skipped;
+  if (!ctx.named.has("RT-06"))
+    return say(ctx.locale, "skip", COPY.named, { id: "RT-06" });
+  const ready = prepare(ctx, LIVE);
+  if (isOutcome(ready)) return ready;
+  const field = deviceGap(ctx.env);
+  if (field) return need(ctx, "RT-06", 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 body = { device_uid, device_secret };
+  const codes = [200];
+  const args = ["unlink", "DELETE", "/kiosk/devices/me", codes, body] as const;
+  const step = await live.probe(...args);
+  if (!step.ok) return fromLive(ctx.locale, step.result);
+  return { status: "pass" };
+};
+
+const runRt07 = async (ctx: RunCtx): Promise<Outcome> => {
+  const skipped = applies(ctx, "RT-07", new Set(["kiosk", "dashboard"]));
+  if (skipped) return skipped;
+  const device = textOf(ctx.env.FIRESPARK_DOCTOR_DEVICE_ID);
+  if (!device) return need(ctx, "RT-07", "FIRESPARK_DOCTOR_DEVICE_ID");
+  const cookie = textOf(ctx.env.FIRESPARK_DOCTOR_DASHBOARD_COOKIE);
+  if (!cookie) return need(ctx, "RT-07", "FIRESPARK_DOCTOR_DASHBOARD_COOKIE");
+  const ready = prepare(ctx, ["dashboard_url", "merchant_id", "env"]);
+  if (isOutcome(ready)) return ready;
+  const url = `${textOf(ready.dashboard_url)}/api/trpc/kioskDevices.reboot`;
+  const merchant_id = textOf(ready.merchant_id);
+  const env = textOf(ready.env);
+  const input = { merchant_id, env, id: device };
+  const headers = { "content-type": "application/json", cookie };
+  const signal = AbortSignal.timeout(15000);
+  const payload = JSON.stringify({ json: input });
+  const init = { method: "POST", headers, body: payload, signal };
+  try {
+    const response = await fetch(url, init);
+    if (response.status === 200 || response.status === 412) {
+      return { status: "pass" };
+    }
+    return say(ctx.locale, "fail", COPY.reboot, { status: response.status });
+  } catch {
+    return say(ctx.locale, "fail", COPY.reboot, { status: 0 });
+  }
+};
+
+const runRt08 = async (ctx: RunCtx): Promise<Outcome> => {
+  const allowed = new Set(["kiosk", "pos", "dashboard"]);
+  const skipped = applies(ctx, "RT-08", allowed);
+  if (skipped) return skipped;
+  const ready = prepare(ctx, ["channel_id"]);
+  if (isOutcome(ready)) return ready;
+  const pos = textOf(ready.template) === "pos";
+  const path = pos ? "/pos/devices/me" : "/kiosk/devices/me";
+  return heartbeat(ctx, "RT-08", path);
+};
+
+const runRt09 = async (ctx: RunCtx): Promise<Outcome> => {
+  const allowed = new Set(["kiosk", "pos", "dashboard"]);
+  const skipped = applies(ctx, "RT-09", allowed);
+  if (skipped) return skipped;
+  const ready = prepare(ctx, ["channel_id"]);
+  if (isOutcome(ready)) return ready;
+  const template = textOf(ready.template);
+  if (template === "dashboard") {
+    return say(ctx.locale, "skip", COPY.need, {
+      id: "RT-09",
+      field: "kiosk channel_id"
+    });
+  }
+  const cookie = textOf(ctx.env.FIRESPARK_DOCTOR_DASHBOARD_COOKIE);
+  if (!cookie) {
+    return say(ctx.locale, "skip", COPY.need, {
+      id: "RT-09",
+      field: "FIRESPARK_DOCTOR_DASHBOARD_COOKIE"
+    });
+  }
+  const dash = textOf(ready.dashboard_url);
+  if (!dash) {
+    return say(ctx.locale, "skip", COPY.need, {
+      id: "RT-09",
+      field: "dashboard_url"
+    });
+  }
+  const input = {
+    merchant_id: textOf(ready.merchant_id),
+    env: textOf(ready.env),
+    channel_id: textOf(ready.channel_id)
+  };
+  const proc = "kioskDevices.selectByRange";
+  const step = await trpcCall(dash, cookie, proc, input);
+  if (step.status < 200 || step.status >= 300) {
+    return say(ctx.locale, "fail", COPY.reboot, { status: step.status });
+  }
+  if (!step.text.includes("store_id")) {
+    return say(ctx.locale, "fail", COPY.need, { id: "RT-09", field: "stores" });
+  }
+  if (step.text.includes("PENDING") && !step.text.includes("LINKED")) {
+    return say(ctx.locale, "fail", COPY.need, { id: "RT-09", field: "link" });
+  }
+  if (!step.text.includes("is_online")) {
+    return say(ctx.locale, "fail", COPY.need, { id: "RT-09", field: "online" });
+  }
+  return { status: "pass" };
+};
+
+const runPrt01 = async (ctx: RunCtx): Promise<Outcome> => {
+  const skipped = applies(ctx, "PRT-01", new Set(["pos"]));
+  if (skipped) return skipped;
+  const files = await readSources(ctx.cwd);
+  const found = files.some(file => file.body.includes("printReceipt"));
+  if (!found) return say(ctx.locale, "fail", COPY.print);
+  return { status: "pass" };
+};
+
+const currentSession = async (ctx: RunCtx, id: string) => {
+  const ready = prepare(ctx, LIVE);
+  if (isOutcome(ready)) return ready;
+  const field = deviceGap(ctx.env);
+  if (field) return need(ctx, id, 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 body = { device_uid, device_secret };
+  const codes = [200];
+  const p1 = ["session", "POST", "/pos/sessions/current"] as const;
+  const args = [...p1, codes, body] as const;
+  const step = await live.probe(...args);
+  if (!step.ok) return fromLive(ctx.locale, step.result);
+  return { status: "pass" as const };
+};
+
+const runCaj01 = async (ctx: RunCtx): Promise<Outcome> => {
+  const skipped = applies(ctx, "CAJ-01", new Set(["pos", "dashboard"]));
+  if (skipped) return skipped;
+  return currentSession(ctx, "CAJ-01");
+};
+
+const runCaj02 = async (ctx: RunCtx): Promise<Outcome> => {
+  const skipped = applies(ctx, "CAJ-02", new Set(["pos"]));
+  if (skipped) return skipped;
+  return currentSession(ctx, "CAJ-02");
+};
+
+const runCaj03 = async (ctx: RunCtx): Promise<Outcome> => {
+  const skipped = applies(ctx, "CAJ-03", new Set(["pos"]));
+  if (skipped) return skipped;
+  return currentSession(ctx, "CAJ-03");
+};
+
+const pageOf = async (ctx: RunCtx, id: string) => {
+  const ready = prepare(ctx, ["url"]);
+  if (isOutcome(ready)) return ready;
+  let page: { status: number; body: string };
+  try {
+    page = await readPage(textOf(ready.url));
+  } catch {
+    return say(ctx.locale, "fail", COPY.page);
+  }
+  if (page.status >= 400) return say(ctx.locale, "fail", COPY.page);
+  if (!page.body.toLowerCase().includes("whatsapp") && id === "CHT-01") {
+    return need(ctx, id, "url");
+  }
+  return { status: "pass" as const };
+};
+
+const runCht01 = async (ctx: RunCtx): Promise<Outcome> => {
+  const skipped = applies(ctx, "CHT-01", new Set(["chat", "dashboard"]));
+  if (skipped) return skipped;
+  return pageOf(ctx, "CHT-01");
+};
+
+const runCht03 = async (ctx: RunCtx): Promise<Outcome> => {
+  const allowed = new Set(["chat", "call-center", "dashboard"]);
+  const skipped = applies(ctx, "CHT-03", allowed);
+  if (skipped) return skipped;
+  return pageOf(ctx, "CHT-03");
+};
+
+export const OPS_BINDINGS: Record<string, CheckBinding> = {
+  "RT-06": withSafeFix(runRt06),
+  "RT-07": withSafeFix(runRt07),
+  "RT-08": withSafeFix(runRt08),
+  "RT-09": withSafeFix(runRt09),
+  "RT-10": withSafeFix(runRt10),
+  "PRT-01": withSafeFix(runPrt01),
+  "CAJ-01": withSafeFix(runCaj01),
+  "CAJ-02": withSafeFix(runCaj02),
+  "CAJ-03": withSafeFix(runCaj03),
+  "CHT-01": withSafeFix(runCht01),
+  "CHT-03": withSafeFix(runCht03)
+};

package/src/commands/doctor/client/options.ts

@@ -0,0 +1,201 @@
+import type { Copy } from "../../../core/i18n";
+import type { OptionSpec } from "../../../core/options";
+
+const text = (es: string, en: string, pt: string): Copy => {
+  return { "es-EC": es, "en-US": en, "pt-BR": pt };
+};
+
+const option = (spec: OptionSpec) => spec;
+
+export const CLIENT_OPTIONS: OptionSpec[] = [
+  option({
+    name: "config",
+    kind: "string",
+    env: "FIRESPARK_DOCTOR_CONFIG",
+    description: text(
+      "YAML de config (por ejemplo .bembos.doctor.yml).",
+      "Config YAML (for example .bembos.doctor.yml).",
+      "YAML de config (por exemplo .bembos.doctor.yml)."
+    )
+  }),
+  option({
+    name: "channel",
+    kind: "string",
+    description: text(
+      "Filtra por canal: kiosk, pos, web, app, chat, call-center, server, dashboard.",
+      "Filter by channel: kiosk, pos, web, app, chat, call-center, server, dashboard.",
+      "Filtra por canal: kiosk, pos, web, app, chat, call-center, server, dashboard."
+    )
+  }),
+  option({
+    name: "platform",
+    kind: "string",
+    description: text(
+      "Filtra por capa: web, android, ios, dashboard.",
+      "Filter by platform: web, android, ios, dashboard.",
+      "Filtra por plataforma: web, android, ios, dashboard."
+    )
+  }),
+  option({
+    name: "required",
+    kind: "boolean",
+    description: text(
+      "Solo checks con Requerido = sí.",
+      "Only checks with Required = yes.",
+      "Só checks com Obrigatório = sim."
+    )
+  }),
+  option({
+    name: "area",
+    kind: "string",
+    description: text(
+      "Filtra por área (Pagos, Órdenes, Menú, SDK y config, …).",
+      "Filter by area (Payments, Orders, Menu, SDK and config, …).",
+      "Filtra por área (Pagamentos, Pedidos, Cardápio, SDK e config, …)."
+    )
+  }),
+  option({
+    name: "verification",
+    kind: "string",
+    description: text(
+      "Filtra por verificación: Determinística o Mezcla.",
+      "Filter by verification: Deterministic or Mixed.",
+      "Filtra por verificação: Determinística ou Mista."
+    )
+  }),
+  option({
+    name: "fix",
+    kind: "boolean",
+    description: text(
+      "Intenta arreglar los checks con Fixable = sí. Sin esta flag, solo informa.",
+      "Try to repair checks with Fixable = yes. Without this flag, only report.",
+      "Tenta reparar os checks com Fixable = sim. Sem esta flag, só informa."
+    )
+  }),
+  option({
+    name: "url",
+    kind: "string",
+    description: text(
+      "URL pública del canal desplegado.",
+      "Public URL of the deployed channel.",
+      "URL pública do canal implantado."
+    )
+  }),
+  option({
+    name: "dashboard-url",
+    kind: "string",
+    description: text(
+      "URL del dashboard desplegado.",
+      "URL of the deployed dashboard.",
+      "URL do dashboard implantado."
+    )
+  }),
+  option({
+    name: "api-url",
+    kind: "string",
+    env: "FIRESPARK_API_URL",
+    description: text(
+      "URL de la API del merchant.",
+      "Merchant API URL.",
+      "URL da API do merchant."
+    )
+  }),
+  option({
+    name: "merchant-id",
+    kind: "string",
+    env: "FIRESPARK_DOCTOR_MERCHANT_ID",
+    description: text("ID del merchant.", "Merchant id.", "ID do merchant.")
+  }),
+  option({
+    name: "env",
+    kind: "string",
+    env: "FIRESPARK_DOCTOR_ENVIRONMENT",
+    description: text(
+      "ID o nombre del ambiente.",
+      "Environment id or name.",
+      "ID ou nome do ambiente."
+    )
+  }),
+  option({
+    name: "store-id",
+    kind: "string",
+    env: "FIRESPARK_DOCTOR_STORE_ID",
+    description: text("ID de la tienda.", "Store id.", "ID da loja.")
+  }),
+  option({
+    name: "channel-id",
+    kind: "string",
+    env: "FIRESPARK_DOCTOR_CHANNEL_ID",
+    description: text(
+      "channel_id del canal en el YAML.",
+      "channel_id of the channel in the YAML.",
+      "channel_id do canal no YAML."
+    )
+  }),
+  option({
+    name: "fulfillment-id",
+    kind: "string",
+    env: "FIRESPARK_DOCTOR_FULFILLMENT_ID",
+    description: text(
+      "ID del fulfillment.",
+      "Fulfillment id.",
+      "ID do fulfillment."
+    )
+  }),
+  option({
+    name: "payment",
+    kind: "string",
+    description: text(
+      "Modo de pago: cash o sandbox. Nunca un cobro real.",
+      "Payment mode: cash or sandbox. Never a real charge.",
+      "Modo de pagamento: cash ou sandbox. Nunca uma cobrança real."
+    )
+  }),
+  option({
+    name: "receiver",
+    kind: "string",
+    description: text(
+      "URL del receptor de webhooks.",
+      "Webhook receiver URL.",
+      "URL do receptor de webhooks."
+    )
+  }),
+  option({
+    name: "evidence",
+    kind: "string",
+    description: text(
+      "Ruta local donde se guarda la evidencia.",
+      "Local path where evidence is stored.",
+      "Caminho local onde a evidência é guardada."
+    )
+  }),
+  option({
+    name: "format",
+    kind: "string",
+    env: "FIRESPARK_DOCTOR_FORMAT",
+    defaultValue: "text",
+    description: text(
+      "Formato de salida: text o json.",
+      "Output format: text or json.",
+      "Formato de saída: text ou json."
+    )
+  }),
+  option({
+    name: "strict",
+    kind: "boolean",
+    description: text(
+      "Falla si algún check se omite.",
+      "Fail when any check is skipped.",
+      "Falha se algum check for omitido."
+    )
+  }),
+  option({
+    name: "deployed",
+    kind: "boolean",
+    description: text(
+      "En init, marca el canal como desplegado.",
+      "On init, mark the channel as deployed.",
+      "No init, marca o canal como implantado."
+    )
+  })
+];