@nihinmedia/medgen-react-native 1.0.12

package/lib/module/bridge.js

@@ -0,0 +1,182 @@
+import { SDK_VERSION } from "./client";
+
+import * as native from "./native";
+
+import { sanitizeLinks } from "./pdfLinks";
+
+const V = 1;
+
+const ok = (id, payload) => JSON.stringify({
+  v: V,
+  id: id,
+  ok: true,
+  payload: payload
+});
+
+const fail = (id, code, message) => JSON.stringify({
+  v: V,
+  id: id,
+  ok: false,
+  error: {
+    code: code,
+    message: message
+  }
+});
+
+export async function handleBridgeMessage(raw, reply, ctx) {
+  const trace = (why, detail) => {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.warn(`[MedGen] bridge dropped a frame: ${why}`, detail ?? "");
+    }
+  };
+  let msg;
+  try {
+    msg = JSON.parse(raw);
+  } catch {
+    return;
+  }
+  if (msg.v !== V) {
+    trace(`protocol version ${String(msg.v)} (this SDK speaks v${V})`);
+    return;
+  }
+  if (!msg.id || !msg.method) {
+    trace("missing id or method", msg);
+    return;
+  }
+  const {handlers: handlers, capabilities: capabilities, onClose: onClose, nonce: nonce} = ctx;
+  if (typeof msg.nonce !== "string" || msg.nonce.length !== nonce.length || msg.nonce !== nonce) {
+    trace(typeof msg.nonce !== "string" ? `no nonce on "${String(msg.method)}" — the surface is not sending ` + "window.__medgenNonce. Every native call will be dropped." : `nonce mismatch on "${String(msg.method)}" — a subframe, or a stale page`);
+    return;
+  }
+  const {id: id, method: method} = msg;
+  const payload = msg.payload ?? {};
+  try {
+    switch (method) {
+     case "system.ready":
+      reply(ok(id, {
+        platform: "react-native",
+        version: SDK_VERSION,
+        features: {
+          share: capabilities.share && (Boolean(handlers.onShare) || native.canShareText()),
+          clipboard: capabilities.clipboard && (Boolean(handlers.onCopy) || native.canCopy()),
+          speech: Boolean(handlers.onSpeechStart) && capabilities.dictation,
+          fileUpload: Boolean(handlers.onFilePick) && capabilities.fileUpload,
+          downloadPdf: capabilities.downloadPdf && (Boolean(handlers.onSavePdf) || native.canRenderPdf())
+        }
+      }));
+      return;
+
+     case "system.dismiss":
+      onClose();
+      reply(ok(id));
+      return;
+
+     case "share.content":
+      {
+        if (!capabilities.share) return reply(fail(id, "FORBIDDEN", "share not granted"));
+        const text = String(payload.text ?? "");
+        const completed = handlers.onShare ? await handlers.onShare(text) : await native.shareText(text);
+        reply(ok(id, {
+          completed: completed
+        }));
+        return;
+      }
+
+     case "clipboard.write":
+      {
+        if (!capabilities.clipboard) return reply(fail(id, "FORBIDDEN", "clipboard not granted"));
+        const text = String(payload.text ?? "");
+        const html = capabilities.richClipboard ? payload.html : undefined;
+        const written = handlers.onCopy ? await handlers.onCopy({
+          text: text,
+          html: html
+        }) : await native.writeClipboard(text, html);
+        reply(ok(id, {
+          written: written
+        }));
+        return;
+      }
+
+     case "speech.start":
+      {
+        if (!capabilities.dictation) return reply(fail(id, "FORBIDDEN", "dictation not granted"));
+        if (!handlers.onSpeechStart) return reply(fail(id, "UNAVAILABLE", "No speech handler"));
+        await handlers.onSpeechStart();
+        reply(ok(id, {
+          listening: true
+        }));
+        return;
+      }
+
+     case "speech.stop":
+      {
+        if (!capabilities.dictation) return reply(fail(id, "FORBIDDEN", "dictation not granted"));
+        if (!handlers.onSpeechStop) return reply(fail(id, "UNAVAILABLE", "No speech handler"));
+        const transcript = await handlers.onSpeechStop();
+        reply(ok(id, {
+          transcript: transcript
+        }));
+        return;
+      }
+
+     case "pdf.save":
+      {
+        const html = String(payload.html ?? "");
+        const fileName = String(payload.fileName ?? "MedGen.pdf");
+        const links = sanitizeLinks(payload.links);
+        if (handlers.onSavePdf) {
+          const saved = await handlers.onSavePdf({
+            html: html,
+            fileName: fileName,
+            links: links
+          });
+          return reply(ok(id, {
+            saved: saved
+          }));
+        }
+        const path = await native.renderPdf(html, fileName, links);
+        if (!path) {
+          return reply(fail(id, "UNAVAILABLE", "PDF rendering needs react-native-html-to-pdf, or an onSavePdf handler"));
+        }
+        if (capabilities.downloadToDevice) {
+          const result = await native.saveToDownloads(path, fileName);
+          if (result.saved) return reply(ok(id, {
+            saved: true,
+            uri: result.uri
+          }));
+        }
+        const shared = await native.shareFile(path, "application/pdf", fileName);
+        reply(ok(id, {
+          saved: shared.saved,
+          uri: shared.uri,
+          reason: shared.reason
+        }));
+        return;
+      }
+
+     case "file.pick":
+     case "file.capture":
+      {
+        if (!capabilities.fileUpload) return reply(fail(id, "FORBIDDEN", "file upload not granted"));
+        if (!handlers.onFilePick) return reply(ok(id, {
+          files: []
+        }));
+        const files = await handlers.onFilePick();
+        reply(ok(id, {
+          files: files
+        }));
+        return;
+      }
+
+     default:
+      trace(`unknown method "${String(method)}" — SDK v${SDK_VERSION}`);
+      reply(fail(id, "UNSUPPORTED", `Unknown method: ${String(method)}`));
+      return;
+    }
+  } catch (e) {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.warn("[MedGen] native handler failed:", e);
+    }
+    reply(fail(id, "HANDLER_ERROR", "Handler failed"));
+  }
+}

package/lib/module/client.js

@@ -0,0 +1,391 @@
+import { Platform } from "react-native";
+
+import { registerNativeModules } from "./native";
+
+import * as Keychain from "react-native-keychain";
+
+import { MedGenError } from "./types";
+
+const KEYCHAIN_SERVICE = "jp.nihinmedia.medgen";
+
+const ASSERTION_TIMEOUT_MS = 1e4;
+
+const ATTESTATION_TIMEOUT_MS = 15e3;
+
+export const SDK_VERSION = "1.0.12";
+
+const DEFAULT_API = {
+  development: "https://dev.sugoimed.com",
+  staging: "https://staging.sugoimed.com",
+  production: "https://medgen.nihinmedia.jp"
+};
+
+const DEFAULT_EMBED = {
+  development: "https://dev.sugoimed.com",
+  staging: "https://staging.sugoimed.com",
+  production: "https://medgen.nihinmedia.jp"
+};
+
+let config = null;
+
+export function configure(cfg) {
+  config = cfg;
+  if (cfg.nativeModules) registerNativeModules(cfg.nativeModules);
+}
+
+export function resetConfig() {
+  config = null;
+}
+
+export function requireConfig() {
+  if (!config) {
+    throw new MedGenError("NOT_INITIALIZED", "Call MedGen.initialize() before present()");
+  }
+  return config;
+}
+
+function requireHttps(url, field) {
+  const lower = url.toLowerCase();
+  const isLocal = lower.startsWith("http://localhost") || lower.startsWith("http://127.0.0.1");
+  if (!lower.startsWith("https://") && !isLocal) {
+    throw new MedGenError("NOT_INITIALIZED", `${field} must use https:// — refusing to send an assertion over plaintext`);
+  }
+  return url.replace(/\/+$/, "");
+}
+
+export const apiBase = () => {
+  const cfg = requireConfig();
+  const base = cfg.apiBaseUrl ?? DEFAULT_API[cfg.environment] ?? DEFAULT_API.staging;
+  return requireHttps(base, "apiBaseUrl");
+};
+
+export const embedBase = () => {
+  const cfg = requireConfig();
+  const base = cfg.embedBaseUrl ?? DEFAULT_EMBED[cfg.environment] ?? DEFAULT_EMBED.staging;
+  return requireHttps(base, "embedBaseUrl");
+};
+
+export function emit(name, detail) {
+  const handler = config?.onEvent;
+  if (!handler) return;
+  const event = {
+    name: name,
+    at: Date.now(),
+    detail: detail
+  };
+  try {
+    handler(event);
+  } catch {}
+}
+
+export async function storeCredentials(creds) {
+  await Keychain.setGenericPassword("medgen", JSON.stringify(creds), {
+    service: KEYCHAIN_SERVICE,
+    accessible: Keychain.ACCESSIBLE.AFTER_FIRST_UNLOCK_THIS_DEVICE_ONLY
+  });
+}
+
+export async function readCredentials() {
+  try {
+    const res = await Keychain.getGenericPassword({
+      service: KEYCHAIN_SERVICE
+    });
+    if (!res) return null;
+    return JSON.parse(res.password);
+  } catch {
+    return null;
+  }
+}
+
+export async function clearCredentials() {
+  await Keychain.resetGenericPassword({
+    service: KEYCHAIN_SERVICE
+  });
+}
+
+function withTimeout(p, ms, code, what) {
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new MedGenError(code, `${what} exceeded ${ms}ms`, true)), ms);
+  });
+  return Promise.race([ p, timeout ]).finally(() => clearTimeout(timer));
+}
+
+async function fetchAssertion() {
+  const {assertionProvider: assertionProvider, assertion: assertion} = requireConfig();
+  if (!assertionProvider) {
+    if (assertion) return assertion;
+    throw new MedGenError("NOT_INITIALIZED", "Set assertionProvider (or, to try the SDK once, assertion) in MedGen.initialize()");
+  }
+  try {
+    return await withTimeout(assertionProvider(), ASSERTION_TIMEOUT_MS, "ASSERTION_PROVIDER_TIMEOUT", "Assertion provider");
+  } catch (e) {
+    if (e instanceof MedGenError) throw e;
+    throw new MedGenError("ASSERTION_PROVIDER_FAILED", e instanceof Error ? e.message : "Assertion provider failed", true);
+  }
+}
+
+async function fetchAttestation(assertion) {
+  const {attestationProvider: attestationProvider} = requireConfig();
+  if (!attestationProvider) return "";
+  try {
+    return await withTimeout(attestationProvider(assertion), ATTESTATION_TIMEOUT_MS, "ATTESTATION_FAILED", "Attestation provider");
+  } catch (e) {
+    if (e instanceof MedGenError) throw e;
+    throw new MedGenError("ATTESTATION_FAILED", e instanceof Error ? e.message : "Attestation provider failed", true);
+  }
+}
+
+const CAPABILITY_DEFAULTS = {
+  theming: false,
+  customLogo: false,
+  customMonogram: false,
+  hideAttribution: false,
+  topbar: true,
+  newChat: true,
+  sidebar: false,
+  networkBanner: true,
+  notifications: false,
+  referral: false,
+  announcements: false,
+  appDownloadPrompt: false,
+  notes: false,
+  questionForum: false,
+  workshopVideos: false,
+  collections: false,
+  ads: false,
+  navBar: false,
+  settings: false,
+  settingsLegal: true,
+  settingsTheme: false,
+  settingsSupport: false,
+  settingsSystemInfo: false,
+  settingsLogout: false,
+  profileAccount: false,
+  profileDeleteAccount: false,
+  quickAnswer: true,
+  detailedAnswer: true,
+  japaneseAnswer: true,
+  dictation: false,
+  fileUpload: false,
+  clipboard: false,
+  richClipboard: true,
+  share: true,
+  downloadToDevice: false,
+  closeButton: false,
+  downloadPdf: false,
+  chatHistory: true,
+  bookmarks: false,
+  citationsPanel: true,
+  referencesShowMore: true,
+  directLink: true
+};
+
+export function parseBranding(raw) {
+  const src = raw ?? {};
+  const out = {};
+  const asset = value => {
+    if (!value || typeof value !== "object") return undefined;
+    const a = value;
+    if (typeof a.url !== "string" || !a.url) return undefined;
+    return {
+      url: a.url,
+      alt: typeof a.alt === "string" ? a.alt : undefined,
+      width: typeof a.width === "number" ? a.width : undefined,
+      height: typeof a.height === "number" ? a.height : undefined
+    };
+  };
+  const logo = asset(src.logo);
+  if (logo) out.logo = logo;
+  const monogram = asset(src.monogram);
+  if (monogram) out.monogram = monogram;
+  const palette = value => {
+    if (!value || typeof value !== "object") return undefined;
+    const entries = Object.entries(value).filter(([, v]) => typeof v === "string");
+    return entries.length ? Object.fromEntries(entries) : undefined;
+  };
+  const colors = palette(src.colors);
+  if (colors) out.colors = colors;
+  const colorsDark = palette(src.colorsDark);
+  if (colorsDark) out.colorsDark = colorsDark;
+  if (src.attribution && typeof src.attribution === "object") {
+    out.attribution = {
+      hidden: Boolean(src.attribution.hidden)
+    };
+  }
+  return out;
+}
+
+export function parseCapabilities(raw) {
+  const src = raw ?? {};
+  const pick = (key, fallback) => typeof src[key] === "boolean" ? src[key] : fallback;
+  return {
+    theming: pick("theming", CAPABILITY_DEFAULTS.theming),
+    customLogo: pick("custom_logo", CAPABILITY_DEFAULTS.customLogo),
+    customMonogram: pick("custom_monogram", CAPABILITY_DEFAULTS.customMonogram),
+    hideAttribution: pick("hide_attribution", CAPABILITY_DEFAULTS.hideAttribution),
+    topbar: pick("topbar", CAPABILITY_DEFAULTS.topbar),
+    newChat: pick("new_chat", CAPABILITY_DEFAULTS.newChat),
+    sidebar: pick("sidebar", CAPABILITY_DEFAULTS.sidebar),
+    networkBanner: pick("network_banner", CAPABILITY_DEFAULTS.networkBanner),
+    notifications: pick("notifications", CAPABILITY_DEFAULTS.notifications),
+    referral: pick("referral", CAPABILITY_DEFAULTS.referral),
+    announcements: pick("announcements", CAPABILITY_DEFAULTS.announcements),
+    appDownloadPrompt: pick("app_download_prompt", CAPABILITY_DEFAULTS.appDownloadPrompt),
+    notes: pick("notes", CAPABILITY_DEFAULTS.notes),
+    questionForum: pick("question_forum", CAPABILITY_DEFAULTS.questionForum),
+    workshopVideos: pick("workshop_videos", CAPABILITY_DEFAULTS.workshopVideos),
+    collections: pick("collections", CAPABILITY_DEFAULTS.collections),
+    ads: pick("ads", CAPABILITY_DEFAULTS.ads),
+    navBar: pick("nav_bar", CAPABILITY_DEFAULTS.navBar),
+    settings: pick("settings", CAPABILITY_DEFAULTS.settings),
+    settingsLegal: pick("settings_legal", CAPABILITY_DEFAULTS.settingsLegal),
+    settingsTheme: pick("settings_theme", CAPABILITY_DEFAULTS.settingsTheme),
+    settingsSupport: pick("settings_support", CAPABILITY_DEFAULTS.settingsSupport),
+    settingsSystemInfo: pick("settings_system_info", CAPABILITY_DEFAULTS.settingsSystemInfo),
+    settingsLogout: pick("settings_logout", CAPABILITY_DEFAULTS.settingsLogout),
+    profileAccount: pick("profile_account", CAPABILITY_DEFAULTS.profileAccount),
+    profileDeleteAccount: pick("profile_delete_account", CAPABILITY_DEFAULTS.profileDeleteAccount),
+    quickAnswer: pick("quick_answer", CAPABILITY_DEFAULTS.quickAnswer),
+    detailedAnswer: pick("detailed_answer", CAPABILITY_DEFAULTS.detailedAnswer),
+    japaneseAnswer: pick("japanese_answer", CAPABILITY_DEFAULTS.japaneseAnswer),
+    dictation: pick("dictation", CAPABILITY_DEFAULTS.dictation),
+    fileUpload: pick("file_upload", CAPABILITY_DEFAULTS.fileUpload),
+    clipboard: pick("clipboard", CAPABILITY_DEFAULTS.clipboard),
+    richClipboard: pick("rich_clipboard", CAPABILITY_DEFAULTS.richClipboard),
+    share: pick("share", CAPABILITY_DEFAULTS.share),
+    downloadToDevice: pick("download_to_device", CAPABILITY_DEFAULTS.downloadToDevice),
+    closeButton: pick("close_button", CAPABILITY_DEFAULTS.closeButton),
+    downloadPdf: pick("download_pdf", CAPABILITY_DEFAULTS.downloadPdf),
+    chatHistory: pick("chat_history", CAPABILITY_DEFAULTS.chatHistory),
+    bookmarks: pick("bookmarks", CAPABILITY_DEFAULTS.bookmarks),
+    citationsPanel: pick("citations_panel", CAPABILITY_DEFAULTS.citationsPanel),
+    referencesShowMore: pick("references_show_more", CAPABILITY_DEFAULTS.referencesShowMore),
+    directLink: pick("direct_link", CAPABILITY_DEFAULTS.directLink)
+  };
+}
+
+const CLIENT_BY_PLATFORM = {
+  ios: "sdk-ios",
+  android: "sdk-android"
+};
+
+export async function exchange() {
+  emit("exchange.started");
+  const assertion = await fetchAssertion();
+  const attestation = await fetchAttestation(assertion);
+  const client = CLIENT_BY_PLATFORM[Platform.OS] ?? "sdk-ios";
+  const headers = {
+    "Content-Type": "application/json",
+    "X-MedGen-Client": `rn/${SDK_VERSION}`
+  };
+  if (attestation) headers["X-MedGen-Attestation"] = attestation;
+  let res;
+  try {
+    res = await fetch(`${apiBase()}/api/v1/partner/session/exchange`, {
+      method: "POST",
+      headers: headers,
+      body: JSON.stringify({
+        assertion: assertion,
+        client: client
+      })
+    });
+  } catch (e) {
+    const err = new MedGenError("NETWORK_UNAVAILABLE", e instanceof Error ? e.message : "Network unavailable", true);
+    emit("exchange.failed", {
+      code: err.code
+    });
+    throw err;
+  }
+  const body = await res.json().catch(() => ({}));
+  if (!res.ok) {
+    const err = new MedGenError(body.error ?? "UNKNOWN", body.message ?? "Exchange failed", Boolean(body.retryable), body.support_reference);
+    emit("exchange.failed", {
+      code: err.code,
+      status: res.status
+    });
+    throw err;
+  }
+  const access = body.access;
+  const refresh = body.refresh;
+  if (typeof access !== "string" || !access || typeof refresh !== "string" || !refresh) {
+    const err = new MedGenError("UNKNOWN", "Exchange response is missing session tokens", true);
+    emit("exchange.failed", {
+      code: err.code
+    });
+    throw err;
+  }
+  if (typeof body.handoff_code !== "string" || !body.handoff_code) {
+    const err = new MedGenError("UNKNOWN", "Exchange response is missing a handoff code", true);
+    emit("exchange.failed", {
+      code: err.code
+    });
+    throw err;
+  }
+  await storeCredentials({
+    access: access,
+    refresh: refresh
+  });
+  const user = body.user ?? {};
+  const partner = body.partner ?? {};
+  const result = {
+    handoffCode: body.handoff_code,
+    isNewUser: Boolean(user.is_new),
+    emailCollisionPending: body.error === "EMAIL_COLLISION_PENDING",
+    brandingVersion: String(partner.branding_version ?? "1"),
+    branding: parseBranding(body.branding),
+    capabilities: parseCapabilities(partner.capabilities ?? body.capabilities)
+  };
+  emit("exchange.succeeded", {
+    isNewUser: result.isNewUser,
+    emailCollisionPending: result.emailCollisionPending
+  });
+  return result;
+}
+
+const B64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+function toBase64(input) {
+  const bytes = [];
+  const utf8 = encodeURIComponent(input);
+  for (let i = 0; i < utf8.length; i += 1) {
+    if (utf8[i] === "%") {
+      bytes.push(parseInt(utf8.substr(i + 1, 2), 16));
+      i += 2;
+    } else {
+      bytes.push(utf8.charCodeAt(i));
+    }
+  }
+  let out = "";
+  for (let i = 0; i < bytes.length; i += 3) {
+    const b0 = bytes[i];
+    const b1 = bytes[i + 1];
+    const b2 = bytes[i + 2];
+    out += B64_ALPHABET[b0 >> 2];
+    out += B64_ALPHABET[(b0 & 3) << 4 | (b1 ?? 0) >> 4];
+    out += b1 === undefined ? "=" : B64_ALPHABET[(b1 & 15) << 2 | (b2 ?? 0) >> 6];
+    out += b2 === undefined ? "=" : B64_ALPHABET[b2 & 63];
+  }
+  return out;
+}
+
+export function buildEmbedUrl(handoffCode, entryQuestion, capabilities) {
+  const cfg = requireConfig();
+  const params = [ [ "hc", handoffCode ], [ "locale", cfg.locale ?? "ja" ] ];
+  if (cfg.theme && capabilities?.theming !== false) {
+    const branding = {
+      colors: {
+        primary: cfg.theme.primary,
+        secondary: cfg.theme.secondary,
+        accent: cfg.theme.accent,
+        surface: cfg.theme.surface,
+        onSurface: cfg.theme.onSurface
+      },
+      colorsDark: cfg.theme.darkVariant
+    };
+    params.push([ "theme", toBase64(JSON.stringify(branding)) ]);
+  }
+  if (entryQuestion) params.push([ "q", entryQuestion ]);
+  const query = params.map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`).join("&");
+  return `${embedBase()}/embed?${query}`;
+}