@fire-spark/cli 0.0.0-stage → 0.13.3

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

@@ -0,0 +1,179 @@
+import type { Locale } from "../../../core/i18n";
+import { translate } from "../../../core/i18n";
+import { UsageError } from "../../../core/options";
+import { COPY } from "./copy";
+
+export interface YamlChannel {
+  channel_id: string | null;
+  name: string;
+  template: string;
+  template_version: string | null;
+  sdk_version: string | null;
+  deployed: boolean;
+  url: string | null;
+  dashboard_url: string | null;
+  api_url: string | null;
+  store_id: string | null;
+  fulfillment_id: string | null;
+  payment: string | null;
+  receiver: string | null;
+  evidence: string | null;
+  env: string | null;
+  merchant_id: string | null;
+}
+
+export interface DoctorFile {
+  channels: YamlChannel[];
+}
+
+const KEYS = [
+  "channel_id",
+  "name",
+  "template",
+  "template_version",
+  "sdk_version",
+  "deployed",
+  "url",
+  "dashboard_url",
+  "api_url",
+  "store_id",
+  "fulfillment_id",
+  "payment",
+  "receiver",
+  "evidence",
+  "env",
+  "merchant_id"
+] as const;
+
+type ChannelKey = (typeof KEYS)[number];
+
+const KEY_SET = new Set<string>(KEYS);
+
+export const emptyChannel = (): YamlChannel => {
+  return {
+    channel_id: null,
+    name: "",
+    template: "",
+    template_version: null,
+    sdk_version: null,
+    deployed: false,
+    url: null,
+    dashboard_url: null,
+    api_url: null,
+    store_id: null,
+    fulfillment_id: null,
+    payment: null,
+    receiver: null,
+    evidence: null,
+    env: null,
+    merchant_id: null
+  };
+};
+
+const quote = (value: string) => {
+  const escaped = value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+  return `"${escaped}"`;
+};
+
+const scalar = (value: string | boolean | null) => {
+  if (value === null) return "null";
+  if (typeof value === "boolean") return value ? "true" : "false";
+  return quote(value);
+};
+
+export const writeDoctorYaml = (file: DoctorFile) => {
+  const lines = ["channels:"];
+  if (file.channels.length === 0) {
+    lines.push("  []");
+    return `${lines.join("\n")}\n`;
+  }
+  for (const channel of file.channels) {
+    let first = true;
+    for (const key of KEYS) {
+      const rendered = scalar(channel[key]);
+      const pad = first ? "  - " : "    ";
+      lines.push(`${pad}${key}: ${rendered}`);
+      first = false;
+    }
+  }
+  return `${lines.join("\n")}\n`;
+};
+
+const unquote = (raw: string): string | boolean | null => {
+  const text = raw.trim();
+  if (text === "null" || text === "~" || text === "") return null;
+  if (text === "true") return true;
+  if (text === "false") return false;
+  if (text.startsWith('"') && text.endsWith('"') && text.length >= 2) {
+    const inner = text.slice(1, -1);
+    return inner.replace(/\\"/g, '"').replace(/\\\\/g, "\\");
+  }
+  if (text.startsWith("'") && text.endsWith("'") && text.length >= 2) {
+    return text.slice(1, -1);
+  }
+  return text;
+};
+
+const asString = (value: string | boolean | null, key: string) => {
+  if (value === null) return null;
+  if (typeof value === "string") return value;
+  throw new Error(`${key} is not text`);
+};
+
+const assign = (channel: YamlChannel, key: ChannelKey, raw: string) => {
+  const value = unquote(raw);
+  if (key === "deployed") {
+    if (typeof value !== "boolean") throw new Error("deployed");
+    channel.deployed = value;
+    return;
+  }
+  const text = asString(value, key);
+  if (key === "channel_id") {
+    channel.channel_id = text;
+    return;
+  }
+  if (key === "name") {
+    channel.name = text ?? "";
+    return;
+  }
+  if (key === "template") {
+    channel.template = text ?? "";
+    return;
+  }
+  const bag = channel as unknown as Record<ChannelKey, string | null>;
+  bag[key] = text;
+};
+
+export const parseDoctorYaml = (body: string, path: string, locale: Locale) => {
+  const channels: YamlChannel[] = [];
+  let current: YamlChannel | null = null;
+  const fail = (detail: string): never => {
+    throw new UsageError(translate(locale, COPY.badYaml, { path, detail }));
+  };
+  const rows = body.split(/\r?\n/);
+  for (const row of rows) {
+    const line = row.trim();
+    if (!line || line.startsWith("#")) continue;
+    if (line === "channels:" || line === "channels: []" || line === "[]") {
+      continue;
+    }
+    const item = /^-\s+([^:]+):\s*(.*)$/.exec(line);
+    const field = item ? null : /^([^:]+):\s*(.*)$/.exec(line);
+    const match = item ?? field;
+    if (!match) fail(line);
+    const key = match?.[1]?.trim() ?? "";
+    const raw = match?.[2] ?? "";
+    if (!KEY_SET.has(key)) fail(key);
+    if (item || !current) {
+      current = emptyChannel();
+      channels.push(current);
+    }
+    try {
+      assign(current, key as ChannelKey, raw);
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : String(error);
+      fail(detail);
+    }
+  }
+  return { channels } satisfies DoctorFile;
+};

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

@@ -0,0 +1,81 @@
+export type FetchLike = (
+  input: string,
+  init?: RequestInit
+) => Promise<Response>;
+
+export interface HttpRequest {
+  method: "GET" | "POST" | "PATCH" | "DELETE";
+  url: string;
+  token?: string;
+  body?: unknown;
+  timeoutMs: number;
+}
+
+export interface HttpResponse {
+  status: number;
+  headers: Headers;
+  json: unknown;
+  text: string;
+}
+
+export class NetworkError extends Error {}
+
+const parse = (text: string) => {
+  if (!text) return undefined;
+  try {
+    return JSON.parse(text) as unknown;
+  } catch {
+    return undefined;
+  }
+};
+
+export const request = async (
+  fetchImpl: FetchLike,
+  input: HttpRequest
+): Promise<HttpResponse> => {
+  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 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, init);
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new NetworkError(detail);
+  }
+  const text = await response.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. */
+export const errorDetail = (response: HttpResponse) => {
+  const json = response.json as
+    | { error?: unknown; message?: unknown; details?: unknown }
+    | undefined;
+  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));
+  const detail = parts.length > 0 ? parts.join(" · ") : response.text;
+  return detail.replace(/\s+/g, " ").trim().slice(0, 400) || "—";
+};
+
+export const dataOf = <T>(response: HttpResponse) => {
+  return (response.json as { data?: T } | undefined)?.data;
+};
+
+/** Path without query string, safe to print. */
+export const pathOf = (url: string) => {
+  try {
+    return new URL(url).pathname;
+  } catch {
+    return url.split("?")[0] ?? url;
+  }
+};

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

@@ -0,0 +1,250 @@
+import type { Redactor } from "../../../core/redact";
+import type { FetchLike, HttpRequest, HttpResponse } from "./http";
+import { NetworkError, dataOf, errorDetail, pathOf, request } from "./http";
+import { REASONS, fail, skip } from "./result";
+import type { CheckFail, CheckSkip } from "./result";
+
+export const STOREFRONT = "/api/storefront/v1";
+
+export interface MenuProduct {
+  id?: string;
+  uid?: string;
+  name?: string;
+  pricing?: { price?: number };
+}
+
+export interface Menu {
+  id?: string;
+  name?: string;
+  products?: MenuProduct[];
+  categories?: unknown[];
+}
+
+/** What ORD-01 needs to sign in and place one order. */
+export interface LiveConfig {
+  apiUrl?: string;
+  firebaseApiKey?: string;
+  firebaseAuthUrl: string;
+  customerEmail?: string;
+  customerPassword?: string;
+  storeId?: string;
+  channelId?: string;
+  fulfillmentId?: string;
+  currency: string;
+  httpTimeoutMs: number;
+}
+
+export interface LiveDeps {
+  fetch: FetchLike;
+}
+
+type Step<T> =
+  | { ok: true; value: T }
+  | { ok: false; result: CheckFail | CheckSkip };
+
+export interface LiveSession {
+  storefront: <T>(
+    hop: string,
+    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>>;
+}
+
+export interface RealtimeToken {
+  access_token?: string;
+  url?: string;
+  key?: string;
+  customer_topic?: string;
+}
+
+const ok = <T>(value: T): Step<T> => ({ ok: true, value });
+type Miss = CheckFail | CheckSkip;
+const no = <T>(result: Miss): Step<T> => ({ ok: false, result });
+
+const missingSignIn = (config: LiveConfig) => {
+  const names: string[] = [];
+  if (!config.firebaseApiKey) names.push("FIRESPARK_DOCTOR_FIREBASE_API_KEY");
+  if (!config.customerEmail) names.push("FIRESPARK_DOCTOR_CUSTOMER_EMAIL");
+  if (!config.customerPassword) {
+    names.push("FIRESPARK_DOCTOR_CUSTOMER_PASSWORD");
+  }
+  if (!config.apiUrl) names.push("api_url");
+  return names;
+};
+
+const menuQuery = (config: LiveConfig) => {
+  const params = new URLSearchParams();
+  if (config.storeId) params.set("store_id", config.storeId);
+  if (config.channelId) params.set("channel_id", config.channelId);
+  if (config.fulfillmentId) params.set("fulfillment_id", config.fulfillmentId);
+  return params;
+};
+
+export const createLiveSession = (
+  config: LiveConfig,
+  deps: LiveDeps,
+  redactor: Redactor
+): LiveSession => {
+  const memo = new Map<string, Promise<unknown>>();
+  const once = <T>(key: string, factory: () => Promise<T>) => {
+    if (!memo.has(key)) memo.set(key, factory());
+    return memo.get(key) as Promise<T>;
+  };
+
+  const signInGap = () => {
+    const names = missingSignIn(config);
+    if (names.length === 0) return undefined;
+    return skip(REASONS.liveMissing, { names: names.join(", ") });
+  };
+
+  const call = async (
+    hop: string,
+    input: Omit<HttpRequest, "timeoutMs">
+  ): Promise<Step<HttpResponse>> => {
+    try {
+      const timeoutMs = config.httpTimeoutMs;
+      const response = await request(deps.fetch, { ...input, timeoutMs });
+      return ok(response);
+    } catch (error) {
+      const target = `${input.method} ${pathOf(input.url)}`;
+      let detail = String(error);
+      if (error instanceof NetworkError) detail = error.message;
+      return no(fail(hop, REASONS.network, { target, detail }));
+    }
+  };
+
+  const api = (path: string) => `${config.apiUrl ?? ""}${STOREFRONT}${path}`;
+
+  const expectAt = (
+    hop: string,
+    response: HttpResponse,
+    statuses: number[],
+    method: string,
+    url: string
+  ) => {
+    if (statuses.includes(response.status)) return undefined;
+    const path = pathOf(url);
+    const detail = errorDetail(response);
+    const status = response.status;
+    const vars = { method, path, status, detail };
+    return fail(hop, REASONS.httpStatus, vars);
+  };
+
+  const idToken = () => {
+    return once("idToken", async (): Promise<Step<string>> => {
+      const missing = signInGap();
+      if (missing) return no(missing);
+      const base = config.firebaseAuthUrl;
+      const key = encodeURIComponent(config.firebaseApiKey ?? "");
+      const url = `${base}/v1/accounts:signInWithPassword?key=${key}`;
+      const email = config.customerEmail;
+      const password = config.customerPassword;
+      const body = { email, password, returnSecureToken: true };
+      const step = await call("firebase-auth", { method: "POST", url, body });
+      if (!step.ok) return step;
+      const failed = expectAt("firebase-auth", step.value, [200], "POST", url);
+      if (failed) return no(failed);
+      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 });
+        return no(reason);
+      }
+      redactor.add(token);
+      return ok(token);
+    });
+  };
+
+  const accessToken = () => {
+    return once("accessToken", async (): Promise<Step<string>> => {
+      const id = await idToken();
+      if (!id.ok) return id;
+      const url = api("/oauth/exchange");
+      const grant_type = "urn:ietf:params:oauth:grant-type:token-exchange";
+      const subject_token_type = "urn:ietf:params:oauth:token-type:id_token";
+      const b1 = { grant_type, subject_token: id.value, subject_token_type };
+      const posted = { method: "POST" as const, url, body: b1 };
+      const step = await call("token-exchange", posted);
+      if (!step.ok) return step;
+      const codes = [200, 201];
+      const failed = expectAt("token-exchange", step.value, codes, "POST", url);
+      if (failed) return no(failed);
+      const json = step.value.json as
+        | { access_token?: string; data?: { access_token?: string } }
+        | undefined;
+      const token = json?.access_token ?? json?.data?.access_token;
+      if (!token) {
+        const field = "access_token";
+        return no(fail("token-exchange", REASONS.badShape, { field }));
+      }
+      redactor.add(token);
+      return ok(token);
+    });
+  };
+
+  const raw = async (
+    hop: string,
+    method: "GET" | "POST" | "PATCH" | "DELETE",
+    path: string,
+    statuses: number[],
+    body?: unknown
+  ): Promise<Step<HttpResponse>> => {
+    const token = await accessToken();
+    if (!token.ok) return token;
+    const url = api(path);
+    const sent = await call(hop, { method, url, token: token.value, body });
+    if (!sent.ok) return sent;
+    const failed = expectAt(hop, sent.value, statuses, method, url);
+    if (failed) return no(failed);
+    return sent;
+  };
+
+  const storefront = async <T>(
+    hop: string,
+    method: "GET" | "POST" | "PATCH" | "DELETE",
+    path: string,
+    statuses: number[],
+    body?: unknown
+  ): Promise<Step<T>> => {
+    const step = await raw(hop, method, path, statuses, body);
+    if (!step.ok) return step;
+    const data = dataOf<T>(step.value);
+    if (data === undefined) {
+      return no(fail(hop, REASONS.badShape, { field: "data" }));
+    }
+    return ok(data);
+  };
+
+  const menus = () => {
+    return once("menus", () => {
+      const query = menuQuery(config).toString();
+      const path = query ? `/menus?${query}` : "/menus";
+      return storefront<Menu[]>("menu-fetch", "GET", path, [200]);
+    });
+  };
+
+  const realtimeToken = () => {
+    return once("realtimeToken", async () => {
+      const codes = [200, 201];
+      const path = "/realtime/token";
+      const args = ["realtime-token", "POST", path, codes, {}] as const;
+      const step = await storefront<RealtimeToken>(...args);
+      if (step.ok) redactor.add(step.value.access_token);
+      return step;
+    });
+  };
+
+  return { storefront, probe: raw, menus, realtimeToken };
+};

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

@@ -0,0 +1,95 @@
+import { randomBytes } from "node:crypto";
+
+import type { LiveConfig, Menu, MenuProduct } from "./live.session";
+
+export const doctorOrderId = () => {
+  return `ord-doctor-${randomBytes(8).toString("hex")}`;
+};
+
+const money = (price: number) => {
+  const unit = {
+    unit_subtotal: price,
+    unit_discount: 0,
+    unit_tax_total: 0,
+    unit_total: price
+  };
+  const line = {
+    subtotal: price,
+    discount_total: 0,
+    tax_total: 0,
+    total: price
+  };
+  const groupUnit = {
+    unit_group_subtotal: price,
+    unit_group_discount: 0,
+    unit_group_tax_total: 0,
+    unit_group_total: price
+  };
+  const group = {
+    group_subtotal: price,
+    group_discount: 0,
+    group_tax_total: 0,
+    group_total: price
+  };
+  return { ...unit, ...line, ...groupUnit, ...group };
+};
+
+/** One unit of one product, no tax, no discount. Place sends cash. */
+export const buildOrderBody = (input: {
+  id: string;
+  config: LiveConfig;
+  product: MenuProduct;
+  menuId?: string;
+  lineUid: string;
+}) => {
+  const { config, product } = input;
+  const price = product.pricing?.price ?? 0;
+  const head = {
+    type: "PRODUCT",
+    uid: input.lineUid,
+    id: product.id,
+    parent_uid: null,
+    parent_id: null
+  };
+  const meta = {
+    name: product.name ?? product.id,
+    menu_id: input.menuId,
+    metadata: { source: "firespark-doctor" }
+  };
+  const rates = { quantity: 1, tax_rate: null, discount_rate: 0 };
+  const line = { ...head, ...meta, ...rates, ...money(price) };
+  const names = {
+    display_name: "Fire Spark Doctor",
+    first_name: "Fire Spark",
+    last_name: "Doctor"
+  };
+  const customer_info = { ...names, email: config.customerEmail };
+  const phone = { phone: "+593999999999" };
+  const customer = { customer_info: { ...customer_info, ...phone } };
+  const totals = {
+    currency: config.currency,
+    subtotal: price,
+    discount_rate: 0,
+    discount_total: 0,
+    tax_rate: 0,
+    tax_total: 0,
+    total: price
+  };
+  const scope = {
+    store_id: config.storeId,
+    channel_id: config.channelId,
+    fulfillment_id: config.fulfillmentId
+  };
+  const body = { id: input.id, ...scope, is_anonymous: false, customer };
+  return { ...body, lines: [line], totals };
+};
+
+/** The configured product, otherwise the lowest id that has a price. */
+export const pickProduct = (menus: Menu[], productId?: string) => {
+  const products = menus.flatMap(menu => menu.products ?? []);
+  if (productId) return products.find(product => product.id === productId);
+  const priced = products.filter(product => {
+    return typeof product.pricing?.price === "number" && product.id;
+  });
+  return priced.toSorted((a, b) => (a.id ?? "").localeCompare(b.id ?? ""))[0];
+};