@fire-spark/cli 0.0.0-stage → 0.13.3

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

@@ -0,0 +1,630 @@
+import { randomBytes, randomUUID } from "node:crypto";
+
+import type { Copy } from "../../../core/i18n";
+import { dataOf } from "../live/http";
+import { buildOrderBody, pickProduct } from "../live/order";
+import { channelLabel } from "./config";
+import { COPY as BASE } from "./copy";
+import { fromLive, isActive, isLocalHost, isOutcome } from "./flow";
+import { namedOrderSkip, openLive, prepare, queryOf } from "./flow";
+import { readPage, rowsOf, say, textOf, withQuery, withSafeFix } from "./flow";
+import { listManifests, manifestProblem } from "./manifests";
+import { parseLegacyManifest } from "./manifests";
+import type { ManifestFile } from "./manifests";
+import { liveConfigOf } from "./order";
+import { changelogNotes, declaresDep, importsLib } from "./repo.scan";
+import { readSources, semverCmp, workspaceIssues } from "./repo.scan";
+import type { SourceFile } from "./repo.scan";
+import type { Outcome, RunCtx } from "./runner";
+import type { YamlChannel } from "./yaml";
+
+const text = (es: string, en: string, pt: string): Copy => {
+  return { "es-EC": es, "en-US": en, "pt-BR": pt };
+};
+
+const COPY = {
+  noManifest: text(
+    "Este repo no tiene apps/*/src/channel-manifest.json.",
+    "This repo has no apps/*/src/channel-manifest.json.",
+    "Este repo não tem apps/*/src/channel-manifest.json."
+  ),
+  npm: text(
+    "No pude leer la versión latest de npm (@fire-spark/storefront). No inventé una versión.",
+    "Could not read the latest npm version (@fire-spark/storefront). No version was invented.",
+    "Não consegui ler a versão latest do npm (@fire-spark/storefront). Não inventei uma versão."
+  ),
+  sdkBehind: text(
+    "{file} tiene sdkVersion {actual} y npm latest es {expected}.",
+    "{file} has sdkVersion {actual} and npm latest is {expected}.",
+    "{file} tem sdkVersion {actual} e o npm latest é {expected}."
+  ),
+  workspace: text(
+    "@fire-spark/* usa workspace:* (salvo @fire-spark/rn-ui): {detail}",
+    "@fire-spark/* uses workspace:* (except @fire-spark/rn-ui): {detail}",
+    "@fire-spark/* usa workspace:* (exceto @fire-spark/rn-ui): {detail}"
+  ),
+  noChangelog: text(
+    "El canal {channel} le falta el changelog de la plantilla {template}.",
+    "Channel {channel} is missing the changelog for template {template}.",
+    "O canal {channel} falta o changelog da plantilla {template}."
+  ),
+  templateBehind: text(
+    "{channel} tiene templateVersion {actual}. Pendiente {version}: {title}. {description}",
+    "{channel} has templateVersion {actual}. Pending {version}: {title}. {description}",
+    "{channel} tem templateVersion {actual}. Pendente {version}: {title}. {description}"
+  ),
+  storeMissing: text(
+    "GET /stores no incluye la tienda {store} del canal {channel}.",
+    "GET /stores does not include store {store} for channel {channel}.",
+    "GET /stores não inclui a loja {store} do canal {channel}."
+  ),
+  burned: text(
+    "{field} {value} está quemado en {file}.",
+    "{field} {value} is hardcoded in {file}.",
+    "{field} {value} está fixo em {file}."
+  ),
+  page: text(
+    "La URL del canal {channel} respondió {status}.",
+    "The URL of channel {channel} answered {status}.",
+    "A URL do canal {channel} respondeu {status}."
+  ),
+  fulfillment: text(
+    "GET /fulfillment no incluye {id} para el canal {channel}.",
+    "GET /fulfillment does not include {id} for channel {channel}.",
+    "GET /fulfillment não inclui {id} para o canal {channel}."
+  ),
+  payments: text(
+    "GET /payments no trajo métodos para el canal {channel}.",
+    "GET /payments returned no methods for channel {channel}.",
+    "GET /payments não trouxe métodos para o canal {channel}."
+  ),
+  secret: text(
+    "El JS público contiene {name}.",
+    "The public JS contains {name}.",
+    "O JS público contém {name}."
+  ),
+  localApi: text(
+    "api_url del canal {channel} apunta a localhost.",
+    "api_url of channel {channel} points at localhost.",
+    "api_url do canal {channel} aponta para localhost."
+  ),
+  channelOff: text(
+    "El canal {id} no está activo en GET /channels.",
+    "Channel {id} is not active on GET /channels.",
+    "O canal {id} não está ativo em GET /channels."
+  ),
+  emptyMenu: text(
+    "Un channel_id inválido devolvió un menú vacío, no storefront no encontrado.",
+    "An invalid channel_id returned an empty menu, not storefront not found.",
+    "Um channel_id inválido devolveu um cardápio vazio, não storefront não encontrado."
+  ),
+  leakedMenu: text(
+    "Un channel_id inválido devolvió un menú con productos.",
+    "An invalid channel_id returned a menu with products.",
+    "Um channel_id inválido devolveu um cardápio com produtos."
+  ),
+  localBundle: text(
+    "El JS público de {channel} apunta a localhost ({file}).",
+    "The public JS of {channel} points at localhost ({file}).",
+    "O JS público de {channel} aponta para localhost ({file})."
+  ),
+  demo: text(
+    "Aparece texto de muestra ({hit}) en {where}.",
+    "Sample copy ({hit}) appears in {where}.",
+    "Aparece texto de amostra ({hit}) em {where}."
+  ),
+  badId: text(
+    "El id {id} no cumple ord-<store>-<hash> ni isGenId.",
+    "Id {id} is not ord-<store>-<hash> or isGenId.",
+    "O id {id} não cumpre ord-<store>-<hash> nem isGenId."
+  ),
+  posId: text(
+    "En POS el id tiene que ser POS-<client_id> o isGenId. Llegó {id}.",
+    "On POS the id must be POS-<client_id> or isGenId. Got {id}.",
+    "No POS o id tem que ser POS-<client_id> ou isGenId. Chegou {id}."
+  ),
+  noLib: text(
+    "{file} no declara {lib}.",
+    "{file} does not declare {lib}.",
+    "{file} não declara {lib}."
+  ),
+  surface: text(
+    "La superficie {surface} de {channel} no importa {lib}.",
+    "The {surface} surface of {channel} does not import {lib}.",
+    "A superfície {surface} de {channel} não importa {lib}."
+  ),
+  serverSkip: text(
+    "SDK-10 no aplica al canal server.",
+    "SDK-10 does not apply to the server channel.",
+    "SDK-10 não se aplica ao canal server."
+  )
+};
+
+const NPM = "https://registry.npmjs.org/@fire-spark/storefront/latest";
+const LIVE = [
+  "api_url",
+  "channel_id",
+  "FIRESPARK_DOCTOR_CUSTOMER_EMAIL",
+  "FIRESPARK_DOCTOR_CUSTOMER_PASSWORD",
+  "FIRESPARK_DOCTOR_FIREBASE_API_KEY"
+] as const;
+const DEMO = ["Demo Kitchen", "Av. Isla Floreana E5-44", "storefront demo"];
+const SECRETS = [
+  "FIRESPARK_CLIENT_SECRET",
+  "FIRESPARK_WEBHOOK_SECRET",
+  "FIRESPARK_INJECTION_SECRET",
+  "SUPABASE_SERVICE_ROLE",
+  "FIREBASE_PRIVATE_KEY"
+];
+const HASH = "0123456789abcdefghijklmnopqrstuvwxyz";
+const ORDER_RE = /^ord-[A-Za-z0-9]+-[0-9a-z]{12}$/;
+const POS_RE = /^POS-[A-Za-z0-9]+$/;
+const GEN_RUN = /[0-9a-z]{8}/;
+const PUBLIC_JS = /\.(js|mjs|cjs|html)$/;
+const CODE = /\.(ts|tsx|js|jsx|mjs|cjs)$/;
+
+interface Identity {
+  file: string;
+  appDir: string;
+  channelId: string | null;
+  name: string;
+  template: string;
+  templateVersion: string | null;
+  sdkVersion: string | null;
+}
+
+const missing = (ctx: RunCtx, channel: YamlChannel, field: string) => {
+  const vars = { channel: channelLabel(channel), field };
+  return say(ctx.locale, "fail", BASE.flowMissing, vars);
+};
+
+const identityOf = (file: ManifestFile): Identity | Outcome => {
+  if (file.kind === "json") {
+    const problem = manifestProblem(file.body);
+    if (problem) return { status: "fail", detail: `${file.file}: ${problem}` };
+    const json = JSON.parse(file.body) as Record<string, unknown>;
+    const id = json.channel_id;
+    const channelId = typeof id === "string" ? id : null;
+    const name = typeof json.name === "string" ? json.name : "";
+    const template = String(json.template);
+    const templateVersion = String(json.templateVersion);
+    const sdkVersion = String(json.sdkVersion);
+    const b1 = { file: file.file, appDir: file.appDir, channelId, name };
+    const b2 = { template, templateVersion, sdkVersion };
+    return { ...b1, ...b2 };
+  }
+  const parsed = parseLegacyManifest(file.body);
+  if (!parsed) {
+    const detail = `${file.file}: channel-manifest.ts is not a channel`;
+    return { status: "fail", detail };
+  }
+  const b1 = { file: file.file, appDir: file.appDir };
+  const b2 = { channelId: parsed.channelId, name: parsed.name };
+  const b3 = { template: parsed.template };
+  const b4 = { templateVersion: parsed.templateVersion };
+  const b5 = { sdkVersion: parsed.sdkVersion };
+  return { ...b1, ...b2, ...b3, ...b4, ...b5 };
+};
+
+const identities = async (cwd: string) => {
+  const files = await listManifests(cwd);
+  const rows: Identity[] = [];
+  for (const file of files) {
+    const row = identityOf(file);
+    if (isOutcome(row)) return row;
+    rows.push(row);
+  }
+  return rows;
+};
+
+const latestSdk = async (locale: RunCtx["locale"]) => {
+  try {
+    const signal = AbortSignal.timeout(15000);
+    const response = await fetch(NPM, { signal });
+    const json = (await response.json()) as { version?: unknown };
+    if (response.ok && typeof json.version === "string" && json.version) {
+      return json.version;
+    }
+  } catch {
+    return say(locale, "fail", COPY.npm);
+  }
+  return say(locale, "fail", COPY.npm);
+};
+
+const runSdk01 = async (ctx: RunCtx): Promise<Outcome> => {
+  const rows = await identities(ctx.cwd);
+  if (isOutcome(rows)) return rows;
+  if (rows.length === 0) return say(ctx.locale, "fail", COPY.noManifest);
+  const latest = await latestSdk(ctx.locale);
+  if (typeof latest !== "string") return latest;
+  for (const row of rows) {
+    if (row.sdkVersion === latest) continue;
+    const file = row.file;
+    const actual = row.sdkVersion ?? "";
+    const expected = latest;
+    const vars = { file, actual, expected };
+    return say(ctx.locale, "fail", COPY.sdkBehind, vars);
+  }
+  const issues = workspaceIssues(await readSources(ctx.cwd));
+  const first = issues[0];
+  if (!first) return { status: "pass" };
+  return say(ctx.locale, "fail", COPY.workspace, { detail: first });
+};
+
+const changelogFor = (files: SourceFile[], row: Identity) => {
+  const named = [
+    `templates/${row.template}/CHANGELOG.md`,
+    `${row.appDir}/CHANGELOG.md`,
+    "CHANGELOG.md"
+  ];
+  for (const rel of named) {
+    const file = files.find(item => item.rel === rel);
+    if (file) return changelogNotes(file.body);
+  }
+  return [];
+};
+
+const runSdk02 = async (ctx: RunCtx): Promise<Outcome> => {
+  const rows = await identities(ctx.cwd);
+  if (isOutcome(rows)) return rows;
+  if (rows.length === 0) return say(ctx.locale, "fail", COPY.noManifest);
+  const files = await readSources(ctx.cwd);
+  for (const row of rows) {
+    const notes = changelogFor(files, row);
+    const latest = notes[0];
+    const channel = row.name || row.channelId || row.template;
+    if (!latest) {
+      const vars = { channel, template: row.template };
+      return say(ctx.locale, "fail", COPY.noChangelog, vars);
+    }
+    const actual = row.templateVersion ?? "";
+    if (semverCmp(actual, latest.version) >= 0) continue;
+    const version = latest.version;
+    const title = latest.title || version;
+    const description = latest.description || title;
+    const vars = { channel, actual, version, title, description };
+    return say(ctx.locale, "fail", COPY.templateBehind, vars);
+  }
+  return { status: "pass" };
+};
+
+const burned = (files: SourceFile[], field: string, value: string) => {
+  if (value.length < 4) return null;
+  for (const file of files) {
+    if (file.rel.endsWith(".doctor.yml")) continue;
+    if (file.rel.endsWith("channel-manifest.json")) continue;
+    if (file.rel.endsWith("channel-manifest.ts")) continue;
+    const code = CODE.test(file.rel) || file.rel.endsWith(".env");
+    if (!code) continue;
+    const quoted = file.body.includes(`"${value}"`);
+    const single = file.body.includes(`'${value}'`);
+    if (!quoted && !single) continue;
+    return { field, value, file: file.rel };
+  }
+  return null;
+};
+
+const pageOk = async (
+  ctx: RunCtx,
+  channel: YamlChannel,
+  key: string,
+  id: string
+) => {
+  let page: { status: number; body: string };
+  try {
+    page = await readPage(withQuery(textOf(channel.url), key, id));
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    return { status: "fail" as const, detail };
+  }
+  if (page.status < 400) return null;
+  const vars = { channel: channelLabel(channel), status: page.status };
+  return say(ctx.locale, "fail", COPY.page, vars);
+};
+
+const runSdk03 = async (ctx: RunCtx): Promise<Outcome> => {
+  const ready = prepare(ctx, [...LIVE, "store_id", "url"]);
+  if (isOutcome(ready)) return ready;
+  const live = openLive(ctx, ready);
+  const path = queryOf("/stores", { channel_id: textOf(ready.channel_id) });
+  const stores = await live.storefront<unknown>("stores", "GET", path, [200]);
+  if (!stores.ok) return fromLive(ctx.locale, stores.result);
+  const storeId = textOf(ready.store_id);
+  const rows = rowsOf(stores.value).filter(isActive);
+  if (!rows.some(row => row.id === storeId)) {
+    const vars = { store: storeId, channel: channelLabel(ready) };
+    return say(ctx.locale, "fail", COPY.storeMissing, vars);
+  }
+  const hit = burned(await readSources(ctx.cwd), "store_id", storeId);
+  if (hit) return say(ctx.locale, "fail", COPY.burned, hit);
+  const linked = await pageOk(ctx, ready, "store_id", storeId);
+  if (linked) return linked;
+  return { status: "pass" };
+};
+
+const runSdk04 = async (ctx: RunCtx): Promise<Outcome> => {
+  const ready = prepare(ctx, [...LIVE, "fulfillment_id", "url"]);
+  if (isOutcome(ready)) return ready;
+  const live = openLive(ctx, ready);
+  const query = { channel_id: textOf(ready.channel_id) };
+  const path = queryOf("/fulfillment", query);
+  const hop = "fulfillment";
+  const step = await live.storefront<unknown>(hop, "GET", path, [200]);
+  if (!step.ok) return fromLive(ctx.locale, step.result);
+  const id = textOf(ready.fulfillment_id);
+  const rows = rowsOf(step.value).filter(isActive);
+  if (!rows.some(row => row.id === id)) {
+    const vars = { id, channel: channelLabel(ready) };
+    return say(ctx.locale, "fail", COPY.fulfillment, vars);
+  }
+  const linked = await pageOk(ctx, ready, "fulfillment_id", id);
+  if (linked) return linked;
+  return { status: "pass" };
+};
+
+const scopeQuery = (channel: YamlChannel) => {
+  return {
+    channel_id: textOf(channel.channel_id),
+    store_id: textOf(channel.store_id),
+    fulfillment_id: textOf(channel.fulfillment_id)
+  };
+};
+
+const runSdk05 = async (ctx: RunCtx): Promise<Outcome> => {
+  const ready = prepare(ctx, [...LIVE, "store_id", "fulfillment_id"]);
+  if (isOutcome(ready)) return ready;
+  const live = openLive(ctx, ready);
+  const path = queryOf("/payments", scopeQuery(ready));
+  const step = await live.storefront<unknown>("payments", "GET", path, [200]);
+  if (!step.ok) return fromLive(ctx.locale, step.result);
+  const rows = rowsOf(step.value).filter(isActive);
+  if (rows.length === 0) {
+    const channel = channelLabel(ready);
+    return say(ctx.locale, "fail", COPY.payments, { channel });
+  }
+  const files = await readSources(ctx.cwd);
+  for (const row of rows) {
+    const id = typeof row.id === "string" ? row.id : "";
+    const hit = burned(files, "payment_id", id);
+    if (hit) return say(ctx.locale, "fail", COPY.burned, hit);
+  }
+  return { status: "pass" };
+};
+
+const isGenId = (value: string) => {
+  if (value.length < 8 || value.length > 64) return false;
+  if (!/^[A-Za-z0-9-]+$/.test(value)) return false;
+  if (value.startsWith("-") || value.endsWith("-")) return false;
+  if (value.includes("--")) return false;
+  return GEN_RUN.test(value);
+};
+
+const hash12 = () => {
+  const bytes = randomBytes(12);
+  let out = "";
+  for (const byte of bytes) out += HASH[byte % HASH.length];
+  return out;
+};
+
+const newOrderId = (storeId: string) => {
+  const store = storeId.replace(/[^A-Za-z0-9]/g, "") || "nostore";
+  return `ord-${store}-${hash12()}`;
+};
+
+const ORDER_FIELDS = [
+  ...LIVE,
+  "store_id",
+  "fulfillment_id",
+  "payment",
+  "merchant_id"
+] as const;
+
+const runSdk06 = async (ctx: RunCtx): Promise<Outcome> => {
+  const skipped = namedOrderSkip(ctx, "SDK-06");
+  if (skipped) return skipped;
+  const ready = prepare(ctx, ORDER_FIELDS);
+  if (isOutcome(ready)) return ready;
+  if (ready.template === "pos") {
+    const id = textOf(ctx.env.FIRESPARK_DOCTOR_ORDER_ID);
+    if (!id) return missing(ctx, ready, "FIRESPARK_DOCTOR_ORDER_ID");
+    if (POS_RE.test(id) || isGenId(id)) return { status: "pass" };
+    return say(ctx.locale, "fail", COPY.posId, { id });
+  }
+  const live = openLive(ctx, ready);
+  const menus = await live.menus();
+  if (!menus.ok) return fromLive(ctx.locale, menus.result);
+  const picked = ctx.env.FIRESPARK_DOCTOR_PRODUCT_ID;
+  const product = pickProduct(menus.value, picked);
+  if (!product?.id) return missing(ctx, ready, "menus[].products");
+  const id = newOrderId(textOf(ready.store_id));
+  const menu = menus.value.find(item => item.products?.includes(product));
+  const config = liveConfigOf(ready, ctx.env);
+  const lineUid = randomUUID();
+  const menuId = menu?.id;
+  const b1 = { id, config, product, menuId, lineUid };
+  const body = buildOrderBody(b1);
+  const codes = [201, 202];
+  const args = ["order-create", "POST", "/orders", codes, body] as const;
+  const created = await live.storefront<{ id?: string }>(...args);
+  if (!created.ok) return fromLive(ctx.locale, created.result);
+  const actual = created.value.id ?? "";
+  const valid = actual === id && ORDER_RE.test(actual) && isGenId(actual);
+  if (valid) return { status: "pass" };
+  return say(ctx.locale, "fail", COPY.badId, { id: actual || id });
+};
+
+const hitDemo = (body: string) => {
+  const lower = body.toLowerCase();
+  return DEMO.find(item => lower.includes(item.toLowerCase())) ?? "";
+};
+
+const runSdk07 = async (ctx: RunCtx): Promise<Outcome> => {
+  const ready = prepare(ctx, ["url"]);
+  if (isOutcome(ready)) return ready;
+  const files = await readSources(ctx.cwd);
+  for (const file of files) {
+    const code = CODE.test(file.rel) || file.rel.endsWith(".html");
+    if (!code) continue;
+    const hit = hitDemo(file.body);
+    if (!hit) continue;
+    return say(ctx.locale, "fail", COPY.demo, { hit, where: file.rel });
+  }
+  let page: { status: number; body: string };
+  try {
+    page = await readPage(textOf(ready.url));
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    return { status: "fail", detail };
+  }
+  if (page.status >= 400) {
+    const vars = { channel: channelLabel(ready), status: page.status };
+    return say(ctx.locale, "fail", COPY.page, vars);
+  }
+  const hit = hitDemo(page.body);
+  if (!hit) return { status: "pass" };
+  return say(ctx.locale, "fail", COPY.demo, { hit, where: "url" });
+};
+
+const secretHit = (body: string) => {
+  return SECRETS.find(name => body.includes(name)) ?? "";
+};
+
+const runSdk08 = async (ctx: RunCtx): Promise<Outcome> => {
+  const ready = prepare(ctx, ["url"]);
+  if (isOutcome(ready)) return ready;
+  const files = await readSources(ctx.cwd);
+  for (const file of files) {
+    if (!PUBLIC_JS.test(file.rel)) continue;
+    const name = secretHit(file.body);
+    if (name) return say(ctx.locale, "fail", COPY.secret, { name });
+  }
+  let page: { status: number; body: string };
+  try {
+    page = await readPage(textOf(ready.url));
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    return { status: "fail", detail };
+  }
+  if (page.status >= 400) {
+    const vars = { channel: channelLabel(ready), status: page.status };
+    return say(ctx.locale, "fail", COPY.page, vars);
+  }
+  const name = secretHit(page.body);
+  if (name) return say(ctx.locale, "fail", COPY.secret, { name });
+  return { status: "pass" };
+};
+
+const localJs = (
+  files: SourceFile[],
+  channel: string,
+  locale: RunCtx["locale"]
+) => {
+  for (const file of files) {
+    if (!PUBLIC_JS.test(file.rel)) continue;
+    const local = file.body.includes("localhost");
+    const loop = file.body.includes("127.0.0.1");
+    if (!local && !loop) continue;
+    const vars = { channel, file: file.rel };
+    return say(locale, "fail", COPY.localBundle, vars);
+  }
+  return null;
+};
+
+const runSdk09 = async (ctx: RunCtx): Promise<Outcome> => {
+  const ready = prepare(ctx, [...LIVE, "url"]);
+  if (isOutcome(ready)) return ready;
+  const api = textOf(ready.api_url);
+  if (isLocalHost(api)) {
+    const channel = channelLabel(ready);
+    return say(ctx.locale, "fail", COPY.localApi, { channel });
+  }
+  const files = await readSources(ctx.cwd);
+  const channel = channelLabel(ready);
+  const local = localJs(files, channel, ctx.locale);
+  if (local) return local;
+  const live = openLive(ctx, ready);
+  const hop = "channels";
+  const listed = await live.storefront<unknown>(hop, "GET", "/channels", [200]);
+  if (!listed.ok) return fromLive(ctx.locale, listed.result);
+  const id = textOf(ready.channel_id);
+  const rows = rowsOf(listed.value);
+  const mine = rows.find(row => row.id === id || row.channel_id === id);
+  if (!mine || !isActive(mine)) {
+    return say(ctx.locale, "fail", COPY.channelOff, { id });
+  }
+  const query = queryOf("/menus", { channel_id: "doctor-missing-channel" });
+  const codes = [200, 400, 404];
+  const probe = await live.probe("invalid-channel", "GET", query, codes);
+  if (!probe.ok) return fromLive(ctx.locale, probe.result);
+  if (probe.value.status !== 200) return { status: "pass" };
+  const data = dataOf<unknown>(probe.value);
+  const menus = rowsOf(data);
+  const products = menus.flatMap(row => {
+    return Array.isArray(row.products) ? row.products : [];
+  });
+  if (products.length > 0) return say(ctx.locale, "fail", COPY.leakedMenu);
+  return say(ctx.locale, "fail", COPY.emptyMenu);
+};
+
+const LIBS: Record<string, string> = {
+  app: "@fire-spark/rn-ui",
+  kiosk: "@fire-spark/rn-ui",
+  pos: "@fire-spark/rn-ui",
+  web: "@fire-spark/react-ui",
+  chat: "@fire-spark/react-ui",
+  "call-center": "@fire-spark/react-ui"
+};
+
+const SURFACES = [
+  { id: "menu", test: (rel: string) => rel.toLowerCase().includes("/menu/") },
+  {
+    id: "product",
+    test: (rel: string) => rel.toLowerCase().includes("product")
+  },
+  { id: "cart", test: (rel: string) => rel.toLowerCase().includes("/cart/") },
+  {
+    id: "checkout",
+    test: (rel: string) => rel.toLowerCase().includes("/checkout/")
+  }
+];
+
+const runSdk10 = async (ctx: RunCtx): Promise<Outcome> => {
+  const rows = await identities(ctx.cwd);
+  if (isOutcome(rows)) return rows;
+  if (rows.length === 0) return say(ctx.locale, "fail", COPY.noManifest);
+  const ui = rows.filter(row => LIBS[row.template]);
+  if (ui.length === 0) return say(ctx.locale, "skip", COPY.serverSkip);
+  const files = await readSources(ctx.cwd);
+  for (const row of ui) {
+    const lib = LIBS[row.template] ?? "";
+    const prefix = `${row.appDir}/`;
+    if (!declaresDep(files, prefix, lib)) {
+      return say(ctx.locale, "fail", COPY.noLib, { file: prefix, lib });
+    }
+    const mine = files.filter(file => {
+      return file.rel.startsWith(prefix) && CODE.test(file.rel);
+    });
+    for (const surface of SURFACES) {
+      const group = mine.filter(file => surface.test(file.rel));
+      const imported = group.some(file => importsLib(file.body, lib));
+      if (group.length > 0 && imported) continue;
+      const channel = row.name || row.template;
+      const vars = { surface: surface.id, channel, lib };
+      return say(ctx.locale, "fail", COPY.surface, vars);
+    }
+  }
+  return { status: "pass" };
+};
+
+export const SDK_BINDINGS = {
+  "SDK-01": withSafeFix(runSdk01),
+  "SDK-02": withSafeFix(runSdk02),
+  "SDK-03": withSafeFix(runSdk03),
+  "SDK-04": withSafeFix(runSdk04),
+  "SDK-05": withSafeFix(runSdk05),
+  "SDK-06": withSafeFix(runSdk06),
+  "SDK-07": withSafeFix(runSdk07),
+  "SDK-08": withSafeFix(runSdk08),
+  "SDK-09": withSafeFix(runSdk09),
+  "SDK-10": withSafeFix(runSdk10)
+};