@incode-sdks/incode-integrate 0.1.0

package/agent.js

@@ -0,0 +1,1317 @@
+#!/usr/bin/env node
+
+const fs = require("fs");
+const path = require("path");
+const readline = require("readline");
+const { applyPlan } = require("./executor");
+const { SDK_PACKAGE, scanProject } = require("./scanner");
+
+const DEFAULT_SDK_VERSION = "9.14.0";
+const VERSION_CHOICES = ["9.14.0", "9.13.0"];
+const VARIANT_CHOICES = [
+  { label: "standard", suffix: "" },
+  { label: "streaming", suffix: "vc" },
+  { label: "face-login", suffix: "l" },
+  { label: "nfc", suffix: "nfc" },
+  { label: "e2ee", suffix: "e2ee" },
+];
+const POD_SOURCE_CHOICES = ["ssh", "https"];
+const CONFIG_MODE_CHOICES = ["online", "manual"];
+const IDV_CHOICES = ["standard", "standard-nfc", "standard-recording"];
+const FLOW_HANDLING_CHOICES = ["end-to-end", "step-by-step"];
+const API_URLS = {
+  demo: {
+    label: "Demo",
+    url: "https://demo-api.incodesmile.com",
+  },
+  production: {
+    label: "Production",
+    url: "https://saas-api.incodesmile.com",
+  },
+};
+const DASHBOARD_URL = "https://dashboard.incodesmile.com";
+const LOCAL_SECRET_FILES = [".incode.local.env", ".env.local"];
+
+const IDV_PRESETS = {
+  standard: {
+    description: "Running ID, selfie, and face-match modules...",
+    label: "Standard KYC",
+    modules: [{ module: "IdScan" }, { module: "SelfieScan" }, { module: "FaceMatch" }],
+    sections: [
+      { sectionTag: "id", flowConfig: [{ module: "IdScan" }] },
+      { sectionTag: "selfie", flowConfig: [{ module: "SelfieScan" }, { module: "FaceMatch" }] },
+    ],
+    listeners: [
+      ["IdScanFront", "ID front captured"],
+      ["IdScanBack", "ID back captured"],
+      ["ProcessId", "ID processed"],
+      ["SelfieScan", "Selfie captured"],
+      ["FaceMatch", "Face match completed"],
+    ],
+    variant: "standard",
+  },
+  "standard-nfc": {
+    description: "Running ID, NFC, selfie, and face-match modules...",
+    label: "Standard KYC + NFC",
+    modules: [
+      { module: "IdScan" },
+      { module: "NFCScan", processNFCData: true },
+      { module: "SelfieScan" },
+      { module: "FaceMatch", matchType: "nfc3Way" },
+    ],
+    sections: [
+      { sectionTag: "id", flowConfig: [{ module: "IdScan" }] },
+      { sectionTag: "nfc", flowConfig: [{ module: "NFCScan", processNFCData: true }] },
+      {
+        sectionTag: "selfie",
+        flowConfig: [{ module: "SelfieScan" }, { module: "FaceMatch", matchType: "nfc3Way" }],
+      },
+    ],
+    listeners: [
+      ["IdScanFront", "ID front captured"],
+      ["IdScanBack", "ID back captured"],
+      ["ProcessId", "ID processed"],
+      ["NFCScan", "NFC scan completed"],
+      ["SelfieScan", "Selfie captured"],
+      ["FaceMatch", "Face match completed"],
+    ],
+    variant: "nfc",
+  },
+  "standard-recording": {
+    description: "Running ID, selfie, and face-match modules with session recording...",
+    label: "Standard KYC + Session Recording",
+    modules: [
+      { module: "IdScan", streamFrames: true },
+      { module: "SelfieScan", streamFrames: true },
+      { module: "FaceMatch" },
+    ],
+    recordSessionConfig: { forcePermissions: false, recordSession: true },
+    sections: [
+      { sectionTag: "id", flowConfig: [{ module: "IdScan", streamFrames: true }] },
+      {
+        sectionTag: "selfie",
+        flowConfig: [{ module: "SelfieScan", streamFrames: true }, { module: "FaceMatch" }],
+      },
+    ],
+    listeners: [
+      ["IdScanFront", "ID front captured"],
+      ["IdScanBack", "ID back captured"],
+      ["ProcessId", "ID processed"],
+      ["SelfieScan", "Selfie captured"],
+      ["FaceMatch", "Face match completed"],
+    ],
+    variant: "streaming",
+    videoStreaming: true,
+  },
+};
+
+function parseArgs(argv) {
+  const valueFor = name => {
+    const inline = argv.find(arg => arg.startsWith(`--${name}=`));
+    if (inline) {
+      return inline.slice(name.length + 3);
+    }
+
+    const index = argv.indexOf(`--${name}`);
+    return index >= 0 ? argv[index + 1] : "";
+  };
+  const optionalBoolean = name => {
+    if (argv.includes(`--${name}`)) {
+      return true;
+    }
+
+    if (argv.includes(`--no-${name}`)) {
+      return false;
+    }
+
+    const value = valueFor(name);
+    if (!value) {
+      return undefined;
+    }
+
+    return ["1", "true", "yes", "y"].includes(value.toLowerCase());
+  };
+
+  return {
+    apiKey: valueFor("api-key"),
+    apiUrl: valueFor("api-url"),
+    apply: argv.includes("--apply"),
+    backendSessions: valueFor("backend-sessions"),
+    configurationId: valueFor("configuration-id"),
+    dashboardUrl: valueFor("dashboard-url"),
+    defaults: argv.includes("--yes") || argv.includes("--defaults") || argv.includes("--no-interactive"),
+    dynamicLocalization: optionalBoolean("dynamic-localization"),
+    flow: valueFor("flow"),
+    flowHandling: valueFor("flow-handling"),
+    githubToken: valueFor("github-token"),
+    githubUsername: valueFor("github-username"),
+    idv: valueFor("idv"),
+    npmToken: valueFor("npm-token"),
+    podSource: valueFor("pod-source"),
+    sdkConfig: valueFor("sdk-config") || valueFor("config-mode"),
+    testMode: optionalBoolean("test-mode"),
+    version: valueFor("version"),
+    videoStreaming: optionalBoolean("video-streaming"),
+  };
+}
+
+function normalizeVersion(version) {
+  const trimmed = String(version || "").trim();
+  if (/^\d+\.\d+$/.test(trimmed)) {
+    return `${trimmed}.0`;
+  }
+
+  return trimmed || DEFAULT_SDK_VERSION;
+}
+
+function normalizeVariant(variant) {
+  const normalized = String(variant || "").trim().toLowerCase();
+  const aliases = {
+    "": "standard",
+    default: "standard",
+    face: "face-login",
+    facelogin: "face-login",
+    login: "face-login",
+    l: "face-login",
+    nfc: "nfc",
+    standard: "standard",
+    stream: "streaming",
+    streaming: "streaming",
+    vc: "streaming",
+    video: "streaming",
+    recording: "streaming",
+    e2ee: "e2ee",
+  };
+
+  return aliases[normalized] || normalized;
+}
+
+function variantSuffix(variant) {
+  const selected = VARIANT_CHOICES.find(choice => choice.label === normalizeVariant(variant));
+  if (!selected) {
+    throw new Error(`Unknown SDK variant "${variant}". Use standard, streaming, face-login, nfc, or e2ee.`);
+  }
+
+  return selected.suffix;
+}
+
+function dependencyForRegistry(version, variant) {
+  const normalizedVersion = normalizeVersion(version);
+  const suffix = variantSuffix(variant);
+  return suffix ? `${normalizedVersion}-${suffix}` : normalizedVersion;
+}
+
+function normalizeChoice(value, choices, fallback) {
+  const normalized = String(value || "").trim().toLowerCase();
+  return choices.includes(normalized) ? normalized : fallback;
+}
+
+function normalizeConfigMode(value, fallback = "manual") {
+  const normalized = String(value || "").trim().toLowerCase();
+  if (["online", "dashboard", "remote"].includes(normalized)) {
+    return "online";
+  }
+
+  if (["manual", "code", "in-code", "incode", "local"].includes(normalized)) {
+    return "manual";
+  }
+
+  return fallback;
+}
+
+function normalizeFlowHandling(value, fallback = "end-to-end") {
+  const normalized = String(value || "").trim().toLowerCase();
+  if (["section", "sections", "step", "step-by-step", "sectioned"].includes(normalized)) {
+    return "step-by-step";
+  }
+
+  if (["e2e", "end", "end-to-end", "startonboarding"].includes(normalized)) {
+    return "end-to-end";
+  }
+
+  return fallback;
+}
+
+function normalizeIdv(value, fallback = "standard") {
+  const normalized = String(value || "").trim().toLowerCase();
+  const aliases = {
+    "": fallback,
+    basic: "standard",
+    "basic-kyc": "standard",
+    document: "standard",
+    "document-only": "standard",
+    face: "standard",
+    kyc: "standard",
+    recording: "standard-recording",
+    "session-recording": "standard-recording",
+    "standard+recording": "standard-recording",
+    "standard-recording": "standard-recording",
+    streaming: "standard-recording",
+    video: "standard-recording",
+    nfc: "standard-nfc",
+    "standard+nfc": "standard-nfc",
+    "standard-nfc": "standard-nfc",
+    standard: "standard",
+  };
+
+  return aliases[normalized] || fallback;
+}
+
+function idvForVariant(variant, fallback = "standard") {
+  const normalized = normalizeVariant(variant);
+
+  if (normalized === "nfc") {
+    return "standard-nfc";
+  }
+
+  if (normalized === "streaming") {
+    return "standard-recording";
+  }
+
+  return fallback;
+}
+
+function variantForIdv(idv) {
+  return (IDV_PRESETS[idv] || IDV_PRESETS.standard).variant;
+}
+
+function normalizeBackendSessions(value, fallback = true) {
+  const normalized = String(value || "").trim().toLowerCase();
+  if (["1", "backend", "no-api-key", "true", "yes", "y"].includes(normalized)) {
+    return true;
+  }
+
+  if (["0", "api-key", "client", "false", "no", "n"].includes(normalized)) {
+    return false;
+  }
+
+  return fallback;
+}
+
+function escapeEnvValue(value) {
+  return String(value)
+    .replace(/\\/g, "\\\\")
+    .replace(/"/g, '\\"')
+    .replace(/\$/g, "\\$")
+    .replace(/`/g, "\\`");
+}
+
+function unquoteEnvValue(value) {
+  const trimmed = String(value || "").trim();
+
+  if (
+    (trimmed.startsWith('"') && trimmed.endsWith('"')) ||
+    (trimmed.startsWith("'") && trimmed.endsWith("'"))
+  ) {
+    return trimmed.slice(1, -1);
+  }
+
+  return trimmed;
+}
+
+function isUsableSecret(value) {
+  const trimmed = String(value || "").trim();
+  return Boolean(trimmed) && !/^<.*>$/.test(trimmed);
+}
+
+function parseEnvFile(content) {
+  const values = {};
+
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) {
+      continue;
+    }
+
+    const assignment = trimmed.startsWith("export ")
+      ? trimmed.slice("export ".length).trim()
+      : trimmed;
+    const equalsIndex = assignment.indexOf("=");
+
+    if (equalsIndex <= 0) {
+      continue;
+    }
+
+    const key = assignment.slice(0, equalsIndex).trim();
+    const value = unquoteEnvValue(assignment.slice(equalsIndex + 1));
+
+    if (/^[A-Z0-9_]+$/.test(key) && isUsableSecret(value)) {
+      values[key] = value;
+    }
+  }
+
+  return values;
+}
+
+function readLocalSecrets(root) {
+  return LOCAL_SECRET_FILES.reduce((secrets, file) => {
+    const filePath = path.join(root, file);
+    if (!fs.existsSync(filePath)) {
+      return secrets;
+    }
+
+    return {
+      ...secrets,
+      ...parseEnvFile(fs.readFileSync(filePath, "utf8")),
+    };
+  }, {});
+}
+
+function withHttps(url) {
+  const trimmed = String(url || "").trim();
+  if (!trimmed) {
+    return "";
+  }
+
+  return /^https?:\/\//i.test(trimmed) ? trimmed : `https://${trimmed}`;
+}
+
+function normalizeApiUrl(value, fallback = API_URLS.demo.url) {
+  const trimmed = String(value || "").trim();
+  const normalized = trimmed.toLowerCase();
+
+  if (!trimmed) {
+    return fallback;
+  }
+
+  if (["demo", "demo-api", "sandbox"].includes(normalized)) {
+    return API_URLS.demo.url;
+  }
+
+  if (["prod", "production", "saas", "saas-api"].includes(normalized)) {
+    return API_URLS.production.url;
+  }
+
+  return withHttps(trimmed);
+}
+
+function labelForApiUrl(url) {
+  if (url === API_URLS.demo.url) {
+    return API_URLS.demo.label;
+  }
+
+  if (url === API_URLS.production.url) {
+    return API_URLS.production.label;
+  }
+
+  return "Custom";
+}
+
+function podSourceForMode(mode) {
+  if (mode === "https") {
+    return "source 'https://github.com/Incode-Technologies-Example-Repos/IncdDistributionPodspecs.git'";
+  }
+
+  return "source 'git@github.com:Incode-Technologies-Example-Repos/IncdDistributionPodspecs.git'";
+}
+
+function parseCurrentDependency(dependency) {
+  if (!dependency) {
+    return {
+      source: "registry",
+      variant: "standard",
+      version: DEFAULT_SDK_VERSION,
+    };
+  }
+
+  if (dependency.startsWith("file:")) {
+    return {
+      source: "registry",
+      variant: "standard",
+      version: DEFAULT_SDK_VERSION,
+    };
+  }
+
+  const withoutRange = dependency.replace(/^[~^]/, "");
+  const match = withoutRange.match(/^(\d+\.\d+(?:\.\d+)?)(?:-(vc|l|nfc|e2ee))?$/);
+
+  if (!match) {
+    return {
+      source: "registry",
+      variant: "standard",
+      version: withoutRange,
+    };
+  }
+
+  const suffixToVariant = {
+    e2ee: "e2ee",
+    l: "face-login",
+    nfc: "nfc",
+    vc: "streaming",
+  };
+
+  return {
+    source: "registry",
+    variant: suffixToVariant[match[2]] || "standard",
+    version: normalizeVersion(match[1]),
+  };
+}
+
+function parseStringConstant(content, name) {
+  const single = content.match(new RegExp(`export const ${name}(?::[^=]+)? = '([^']*)'`));
+  if (single) {
+    return single[1];
+  }
+
+  const double = content.match(new RegExp(`export const ${name}(?::[^=]+)? = "([^"]*)"`));
+  return double?.[1] || "";
+}
+
+function parseBooleanConstant(content, name, fallback) {
+  const match = content.match(new RegExp(`export const ${name}(?::[^=]+)? = (true|false)`));
+  return match ? match[1] === "true" : fallback;
+}
+
+function extractConfigurationId(dashboardUrl) {
+  const value = String(dashboardUrl || "").trim();
+  if (!value) {
+    return "";
+  }
+
+  try {
+    const url = new URL(withHttps(value));
+    const fromQuery =
+      url.searchParams.get("configurationId") ||
+      url.searchParams.get("configId") ||
+      url.searchParams.get("configuration");
+
+    if (fromQuery) {
+      return fromQuery;
+    }
+
+    const fromPath = url.pathname.match(/(?:configuration|configurations|flow|flows)\/([^/?#]+)/i);
+    return fromPath?.[1] || "";
+  } catch {
+    return "";
+  }
+}
+
+function inferVariantFromDashboardUrl(dashboardUrl) {
+  const normalized = String(dashboardUrl || "").toLowerCase();
+
+  if (normalized.includes("nfc")) {
+    return "nfc";
+  }
+
+  if (
+    normalized.includes("recording") ||
+    normalized.includes("session-recording") ||
+    normalized.includes("streaming") ||
+    normalized.includes("video")
+  ) {
+    return "streaming";
+  }
+
+  return "";
+}
+
+function inferIdvFromDashboardUrl(dashboardUrl) {
+  return idvForVariant(inferVariantFromDashboardUrl(dashboardUrl), "");
+}
+
+function question(rl, prompt) {
+  return new Promise(resolve => {
+    rl.question(prompt, answer => resolve(answer));
+  });
+}
+
+function secretQuestion(rl, prompt) {
+  if (!rl.output) {
+    return question(rl, prompt);
+  }
+
+  return new Promise(resolve => {
+    const output = rl.output;
+    const originalWrite = output.write;
+
+    output.write = function mutedWrite(stringToWrite, ...args) {
+      if (String(stringToWrite).includes(prompt) || stringToWrite === "\n" || stringToWrite === "\r\n") {
+        return originalWrite.call(output, stringToWrite, ...args);
+      }
+
+      return true;
+    };
+
+    rl.question(prompt, answer => {
+      output.write = originalWrite;
+      console.log("");
+      resolve(answer);
+    });
+  });
+}
+
+function printOptionList(options) {
+  options.forEach((option, index) => {
+    console.log(`  ${index + 1}. ${option}`);
+  });
+}
+
+async function chooseFromList(rl, label, choices, defaultChoice) {
+  console.log("");
+  console.log(label);
+  printOptionList(choices);
+
+  const fallbackIndex = Math.max(choices.indexOf(defaultChoice), 0);
+  const answer = await question(rl, `Choose [${fallbackIndex + 1}]: `);
+  const trimmed = answer.trim();
+
+  if (!trimmed) {
+    return choices[fallbackIndex];
+  }
+
+  const index = Number.parseInt(trimmed, 10);
+  if (Number.isInteger(index) && index >= 1 && index <= choices.length) {
+    return choices[index - 1];
+  }
+
+  if (choices.includes(trimmed)) {
+    return trimmed;
+  }
+
+  return trimmed;
+}
+
+async function chooseBoolean(rl, label, defaultValue) {
+  const defaultLabel = defaultValue ? "yes" : "no";
+  const answer = await question(rl, `${label} [${defaultLabel}]: `);
+  const normalized = answer.trim().toLowerCase();
+
+  if (!normalized) {
+    return defaultValue;
+  }
+
+  return ["1", "true", "yes", "y"].includes(normalized);
+}
+
+async function chooseApiUrl(rl, currentUrl) {
+  const currentLabel = labelForApiUrl(currentUrl).toLowerCase();
+  const choice = await chooseFromList(
+    rl,
+    "Select your API URL",
+    ["demo", "production", "custom"],
+    ["demo", "production"].includes(currentLabel) ? currentLabel : "demo",
+  );
+
+  if (choice === "custom") {
+    return normalizeApiUrl(await question(rl, "Enter custom API URL: "), currentUrl);
+  }
+
+  return normalizeApiUrl(choice, currentUrl);
+}
+
+function inferProductOptions(context) {
+  const localSecrets = readLocalSecrets(context.root);
+  const podfile = context.texts.podfile || "";
+  const androidAppBuildGradle = context.texts.androidAppBuildGradle || "";
+  const incodeFlow = context.texts.incodeFlow || "";
+  const incodeRuntimeConfig = context.texts.incodeRuntimeConfig || "";
+  const currentDependency = parseCurrentDependency(context.sdkDependency);
+
+  const currentIdv =
+    parseStringConstant(incodeFlow, "IDV_PRESET") ||
+    normalizeIdv(parseStringConstant(incodeFlow, "FLOW_PRESET"), "standard");
+  const sdkConfigMode = normalizeConfigMode(parseStringConstant(incodeFlow, "SDK_CONFIGURATION_MODE"), "manual");
+  const flowHandling = normalizeFlowHandling(parseStringConstant(incodeFlow, "FLOW_HANDLING"), "end-to-end");
+  const dashboardUrl = parseStringConstant(incodeFlow, "DASHBOARD_FLOW_URL");
+  const apiUrl = normalizeApiUrl(
+    localSecrets.INCODE_API_URL || parseStringConstant(incodeRuntimeConfig, "INCODE_DEFAULT_API_URL"),
+    API_URLS.demo.url,
+  );
+  const backendSessions = parseBooleanConstant(
+    incodeRuntimeConfig,
+    "INCODE_BACKEND_SESSIONS",
+    true,
+  );
+  const localBackendSessions = localSecrets.INCODE_BACKEND_SESSIONS
+    ? normalizeBackendSessions(localSecrets.INCODE_BACKEND_SESSIONS, backendSessions)
+    : backendSessions;
+  const testMode = parseBooleanConstant(incodeRuntimeConfig, "INCODE_DEFAULT_TEST_MODE", false);
+  const idv = normalizeIdv(currentIdv, idvForVariant(currentDependency.variant));
+  const localNpmToken = localSecrets.NPM_TOKEN || localSecrets.NODE_AUTH_TOKEN || "";
+
+  return {
+    apiKey: localSecrets.INCODE_API_KEY || "",
+    apiKeyProvided: Boolean(localSecrets.INCODE_API_KEY),
+    apiUrl,
+    backendSessions: localBackendSessions,
+    configurationId: extractConfigurationId(dashboardUrl),
+    dashboardUrl,
+    dynamicLocalization: androidAppBuildGradle.includes("com.incode.sdk:extensions"),
+    flowHandling,
+    githubToken: localSecrets.GITHUB_TOKEN || "",
+    githubTokenProvided: Boolean(process.env.GITHUB_TOKEN || localSecrets.GITHUB_TOKEN),
+    githubUsername: localSecrets.GITHUB_USERNAME || "",
+    githubUsernameProvided: Boolean(process.env.GITHUB_USERNAME || localSecrets.GITHUB_USERNAME),
+    idv,
+    npmToken: localNpmToken,
+    npmTokenProvided: Boolean(process.env.NPM_TOKEN || process.env.NODE_AUTH_TOKEN || localNpmToken),
+    podSource: podfile.includes("https://github.com/Incode-Technologies-Example-Repos")
+      ? "https"
+      : "ssh",
+    sdkConfigMode,
+    sdkVariant: currentDependency.variant,
+    sdkVersion: currentDependency.version,
+    testMode,
+    videoStreaming: androidAppBuildGradle.includes("com.incode.sdk:video-streaming"),
+  };
+}
+
+async function promptForProductOptions(context, options) {
+  const current = inferProductOptions(context);
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  console.log("");
+  console.log("Incode React Native integration");
+  console.log("Platform is fixed to React Native for this hackathon agent.");
+
+  try {
+    const githubUsername = await question(
+      rl,
+      `GitHub username for Incode packages [${current.githubUsername || "blank"}]: `,
+    );
+    const githubToken = await secretQuestion(
+      rl,
+      "Paste your Incode customer GitHub token (blank to use env/skip): ",
+    );
+    const npmToken = await secretQuestion(
+      rl,
+      "Paste your React Native NPM token (blank to use env/skip): ",
+    );
+    const apiUrl = await chooseApiUrl(rl, current.apiUrl);
+    const apiKey = await secretQuestion(
+      rl,
+      "Paste your API key (blank if backend initiates sessions): ",
+    );
+    const backendSessions = await chooseBoolean(
+      rl,
+      "Do you initiate sessions on the backend? This enables the no-api-key client approach.",
+      current.backendSessions,
+    );
+    const sdkConfigMode = await chooseFromList(
+      rl,
+      "How do you want to configure the SDK?",
+      CONFIG_MODE_CHOICES,
+      current.sdkConfigMode,
+    );
+
+    let dashboardUrl = current.dashboardUrl;
+    let idv = current.idv;
+
+    if (sdkConfigMode === "online") {
+      console.log("");
+      console.log(
+        `Configure your flow at ${DASHBOARD_URL} in the ${labelForApiUrl(apiUrl)} environment, then paste the flow URL.`,
+      );
+      dashboardUrl = await question(rl, `Dashboard flow URL [${current.dashboardUrl || "blank"}]: `);
+      dashboardUrl = dashboardUrl.trim() || current.dashboardUrl;
+      idv =
+        inferIdvFromDashboardUrl(dashboardUrl) ||
+        current.idv ||
+        "standard";
+    } else {
+      idv = await chooseFromList(
+        rl,
+        "What kind of IDV do you want to perform?",
+        IDV_CHOICES,
+        current.idv,
+      );
+    }
+
+    const flowHandling = await chooseFromList(
+      rl,
+      "How would you like to handle the verification flow?",
+      FLOW_HANDLING_CHOICES,
+      current.flowHandling,
+    );
+    const versionChoices = [...VERSION_CHOICES, "custom"];
+    const defaultVersion = VERSION_CHOICES.includes(current.sdkVersion)
+      ? current.sdkVersion
+      : DEFAULT_SDK_VERSION;
+    const versionChoice = await chooseFromList(
+      rl,
+      "SDK version",
+      versionChoices,
+      defaultVersion,
+    );
+    const sdkVersion =
+      versionChoice === "custom"
+        ? normalizeVersion(await question(rl, "Enter SDK version, for example 9.14.0: "))
+        : versionChoice;
+    const podSource = await chooseFromList(
+      rl,
+      "iOS podspec source",
+      POD_SOURCE_CHOICES,
+      current.podSource,
+    );
+    return {
+      ...current,
+      apiKey: apiKey.trim() || current.apiKey,
+      apiKeyProvided: Boolean(apiKey.trim() || current.apiKey),
+      apiUrl,
+      backendSessions,
+      configurationId: extractConfigurationId(dashboardUrl),
+      dashboardUrl,
+      flowHandling,
+      githubToken: githubToken.trim() || current.githubToken,
+      githubTokenProvided: Boolean(githubToken.trim()) || current.githubTokenProvided,
+      githubUsername: githubUsername.trim() || current.githubUsername,
+      githubUsernameProvided: Boolean(githubUsername.trim()) || current.githubUsernameProvided,
+      idv,
+      npmToken: npmToken.trim() || current.npmToken,
+      npmTokenProvided: Boolean(npmToken.trim()) || current.npmTokenProvided,
+      podSource,
+      sdkConfigMode,
+      sdkVariant: variantForIdv(idv),
+      sdkVersion,
+      videoStreaming: Boolean(IDV_PRESETS[idv].videoStreaming),
+    };
+  } finally {
+    rl.close();
+  }
+}
+
+function chooseProductOptions(context, options) {
+  const current = inferProductOptions(context);
+  const hasExplicitOption =
+    options.apiKey ||
+    options.apiUrl ||
+    options.backendSessions ||
+    options.configurationId ||
+    options.dashboardUrl ||
+    options.dynamicLocalization !== undefined ||
+    options.flow ||
+    options.flowHandling ||
+    options.githubToken ||
+    options.githubUsername ||
+    options.idv ||
+    options.npmToken ||
+    options.podSource ||
+    options.sdkConfig ||
+    options.testMode !== undefined ||
+    options.version ||
+    options.videoStreaming !== undefined;
+
+  const shouldPrompt = process.stdin.isTTY && process.stdout.isTTY && !options.defaults && !hasExplicitOption;
+  if (shouldPrompt) {
+    return promptForProductOptions(context, options);
+  }
+
+  const sdkConfigMode = normalizeConfigMode(options.sdkConfig, current.sdkConfigMode);
+  const dashboardUrl = options.dashboardUrl || current.dashboardUrl;
+  const dashboardIdv = inferIdvFromDashboardUrl(dashboardUrl);
+  const idv =
+    sdkConfigMode === "online" && dashboardIdv
+      ? dashboardIdv
+      : normalizeIdv(options.idv || options.flow, current.idv);
+  const preset = IDV_PRESETS[idv] || IDV_PRESETS.standard;
+
+  return {
+    ...current,
+    apiKey: options.apiKey || current.apiKey,
+    apiKeyProvided: Boolean(options.apiKey || current.apiKey),
+    apiUrl: normalizeApiUrl(options.apiUrl, current.apiUrl),
+    backendSessions: normalizeBackendSessions(options.backendSessions, current.backendSessions),
+    configurationId: options.configurationId || extractConfigurationId(dashboardUrl),
+    dashboardUrl,
+    dynamicLocalization:
+      options.dynamicLocalization === undefined
+        ? current.dynamicLocalization
+        : options.dynamicLocalization,
+    flowHandling: normalizeFlowHandling(options.flowHandling, current.flowHandling),
+    githubToken: options.githubToken || current.githubToken,
+    githubTokenProvided: Boolean(options.githubToken || process.env.GITHUB_TOKEN || current.githubToken),
+    githubUsername: options.githubUsername || current.githubUsername,
+    githubUsernameProvided: Boolean(
+      options.githubUsername || process.env.GITHUB_USERNAME || current.githubUsername,
+    ),
+    idv,
+    npmToken: options.npmToken || current.npmToken,
+    npmTokenProvided: Boolean(
+      options.npmToken || process.env.NPM_TOKEN || process.env.NODE_AUTH_TOKEN || current.npmToken,
+    ),
+    podSource: normalizeChoice(options.podSource, POD_SOURCE_CHOICES, current.podSource),
+    sdkConfigMode,
+    sdkVariant: variantForIdv(idv),
+    sdkVersion: normalizeVersion(options.version || DEFAULT_SDK_VERSION),
+    testMode: options.testMode === undefined ? current.testMode : options.testMode,
+    videoStreaming:
+      options.videoStreaming === undefined
+        ? Boolean(preset.videoStreaming)
+        : options.videoStreaming,
+  };
+}
+
+function chooseSdkSelection(productOptions) {
+  return {
+    dependency: dependencyForRegistry(productOptions.sdkVersion, productOptions.sdkVariant),
+    source: "npm registry",
+    variant: productOptions.sdkVariant,
+    version: productOptions.sdkVersion,
+  };
+}
+
+function toTs(value) {
+  return JSON.stringify(value, null, 2);
+}
+
+function createFlowConfigFile(productOptions) {
+  const flowPreset = IDV_PRESETS[productOptions.idv] || IDV_PRESETS.standard;
+  const listeners = flowPreset.listeners
+    .map(
+      ([module, label]) =>
+        `  { label: '${label}', module: '${module}' },`,
+    )
+    .join("\n");
+  const sessionConfig = productOptions.configurationId
+    ? { configurationId: productOptions.configurationId }
+    : {};
+
+  return `import type {
+  OnboardingFlowConfig,
+  OnboardingRecordSessionConfig,
+  OnboardingSessionConfig,
+  StepCompleteListener,
+} from '@incode-sdks/react-native-incode-sdk';
+
+export type SdkConfigurationMode = 'online' | 'manual';
+
+export type FlowHandling = 'end-to-end' | 'step-by-step';
+
+export const SDK_CONFIGURATION_MODE: SdkConfigurationMode = '${productOptions.sdkConfigMode}';
+
+export const DASHBOARD_FLOW_URL = '${productOptions.dashboardUrl || ""}';
+
+export const IDV_PRESET = '${productOptions.idv}' as const;
+
+export const FLOW_HANDLING: FlowHandling = '${productOptions.flowHandling}';
+
+export const FLOW_LABEL = '${flowPreset.label}';
+
+export const FLOW_DESCRIPTION = '${flowPreset.description}';
+
+export const SESSION_CONFIG: OnboardingSessionConfig = ${toTs(sessionConfig)};
+
+export const FLOW_RECORD_SESSION_CONFIG: OnboardingRecordSessionConfig | undefined = ${
+    flowPreset.recordSessionConfig ? toTs(flowPreset.recordSessionConfig) : "undefined"
+  };
+
+export const FLOW_CONFIG: OnboardingFlowConfig = ${toTs(flowPreset.modules)};
+
+export const SECTION_FLOW_CONFIGS: Array<{
+  flowConfig: OnboardingFlowConfig;
+  sectionTag: string;
+}> = ${toTs(flowPreset.sections)};
+
+export const STEP_LISTENERS: Array<{
+  label: string;
+  module: StepCompleteListener['module'];
+}> = [
+${listeners}
+];
+`;
+}
+
+function createRuntimeConfigFile(productOptions) {
+  return `export const INCODE_DEFAULT_API_URL = '${productOptions.apiUrl}';
+
+export const INCODE_API_URL_LABEL = '${labelForApiUrl(productOptions.apiUrl)}';
+
+export const INCODE_BACKEND_SESSIONS = ${productOptions.backendSessions};
+
+export const INCODE_DEFAULT_TEST_MODE = ${productOptions.testMode};
+`;
+}
+
+function createLocalCredentialEnvFile(productOptions) {
+  const lines = [
+    "# Local Incode SDK credentials and runtime values. This file is ignored by git.",
+    "# Load it with: source .env.local",
+    `export INCODE_API_URL="${escapeEnvValue(productOptions.apiUrl)}"`,
+    `export INCODE_BACKEND_SESSIONS="${productOptions.backendSessions ? "true" : "false"}"`,
+  ];
+
+  if (productOptions.githubToken) {
+    lines.push(
+      `export GITHUB_USERNAME="${escapeEnvValue(
+        productOptions.githubUsername || "<your-github-username>",
+      )}"`,
+    );
+    lines.push(`export GITHUB_TOKEN="${escapeEnvValue(productOptions.githubToken)}"`);
+  } else if (productOptions.githubUsername) {
+    lines.push(`export GITHUB_USERNAME="${escapeEnvValue(productOptions.githubUsername)}"`);
+    lines.push('export GITHUB_TOKEN="${GITHUB_TOKEN:-<your-github-token>}"');
+  }
+
+  if (productOptions.apiKey) {
+    lines.push(`export INCODE_API_KEY="${escapeEnvValue(productOptions.apiKey)}"`);
+  }
+
+  if (productOptions.backendSessions) {
+    lines.push('export INCODE_SESSION_TOKEN="${INCODE_SESSION_TOKEN:-<token-from-your-backend>}"');
+  }
+
+  return `${lines.join("\n")}\n`;
+}
+
+function createNpmrcFile(productOptions) {
+  return `# Local React Native SDK NPM credential. This file is ignored by git.
+@incode-sdks:registry=https://registry.npmjs.org/
+//registry.npmjs.org/:_authToken=${productOptions.npmToken}
+`;
+}
+
+function createExampleFile() {
+  return `import IncodeSdk from '@incode-sdks/react-native-incode-sdk';
+import {
+  FLOW_CONFIG,
+  FLOW_HANDLING,
+  FLOW_RECORD_SESSION_CONFIG,
+  SECTION_FLOW_CONFIGS,
+  SESSION_CONFIG,
+} from './incodeFlow';
+
+export type StartIncodeOptions = {
+  apiKey?: string;
+  apiUrl: string;
+  configurationId?: string;
+  interviewId?: string;
+  // Backend sessions should pass the backend-created session_token here.
+  // The React Native SDK expects it as sessionConfig.token.
+  sessionToken?: string;
+  testMode?: boolean;
+};
+
+function backendSessionApiUrl(apiUrl: string) {
+  return \`\${apiUrl.trim().replace(/\\/+$/, '')}/0/\`;
+}
+
+function buildSessionConfig(options: StartIncodeOptions) {
+  return {
+    ...SESSION_CONFIG,
+    ...(options.configurationId ? { configurationId: options.configurationId } : {}),
+    ...(options.interviewId ? { interviewId: options.interviewId } : {}),
+    ...(options.sessionToken ? { token: options.sessionToken } : {}),
+  };
+}
+
+function recordSessionConfig() {
+  return FLOW_RECORD_SESSION_CONFIG
+    ? { recordSessionConfig: FLOW_RECORD_SESSION_CONFIG }
+    : {};
+}
+
+export async function startConfiguredOnboarding(options: StartIncodeOptions) {
+  const usesBackendSession = Boolean(options.sessionToken);
+  const apiConfig: { key?: string; url: string } = {
+    url: usesBackendSession ? backendSessionApiUrl(options.apiUrl) : options.apiUrl,
+  };
+
+  if (options.apiKey) {
+    apiConfig.key = options.apiKey;
+  }
+
+  await IncodeSdk.initialize({
+    testMode: options.testMode ?? false,
+    apiConfig,
+  });
+
+  const sessionConfig = buildSessionConfig(options);
+
+  if (FLOW_HANDLING === 'step-by-step') {
+    const session = await IncodeSdk.setupOnboardingSession({ sessionConfig });
+    let lastResult: Awaited<ReturnType<typeof IncodeSdk.startOnboardingSection>> | undefined;
+
+    for (const section of SECTION_FLOW_CONFIGS) {
+      lastResult = await IncodeSdk.startOnboardingSection({
+        flowConfig: section.flowConfig,
+        sectionTag: section.sectionTag,
+        ...recordSessionConfig(),
+      });
+
+      if (lastResult.status === 'userCancelled') {
+        return {
+          ...lastResult,
+          interviewId: session.interviewId,
+          token: session.token,
+        };
+      }
+    }
+
+    await IncodeSdk.finishOnboardingFlow();
+
+    return {
+      status: lastResult?.status || 'success',
+      interviewId: session.interviewId,
+      sectionTag: lastResult?.sectionTag,
+      token: session.token,
+    };
+  }
+
+  return IncodeSdk.startOnboarding({
+    flowConfig: FLOW_CONFIG,
+    sessionConfig,
+    ...recordSessionConfig(),
+  });
+}
+
+export async function startIncodeOnboarding(apiUrl: string, apiKey?: string) {
+  return startConfiguredOnboarding({
+    apiKey,
+    apiUrl,
+    testMode: false,
+  });
+}
+`;
+}
+
+function androidFeatureDependencies(productOptions) {
+  const dependencies = [];
+
+  if (productOptions.videoStreaming) {
+    dependencies.push({
+      notation: "com.incode.sdk:video-streaming:1.5.5",
+    });
+  }
+
+  if (productOptions.dynamicLocalization) {
+    dependencies.push({
+      notation: "com.incode.sdk:extensions:1.2.1",
+    });
+  }
+
+  return dependencies;
+}
+
+function generatePlan(context, sdkSelection, productOptions) {
+  const sdkDependency = sdkSelection.dependency;
+  const featureDependencies = androidFeatureDependencies(productOptions);
+  const changes = [
+    {
+      action: "gitignore_entries",
+      entries: [".env.local", ".incode.local.env", ".npmrc"],
+      file: ".gitignore",
+      title: "Keep local SDK credentials out of source control",
+    },
+    {
+      action: "json_dependency",
+      file: context.files.packageJson,
+      name: SDK_PACKAGE,
+      title: `Install ${SDK_PACKAGE}`,
+      version: sdkDependency,
+    },
+    {
+      action: "pod_sources",
+      file: context.files.podfile,
+      sources: [
+        "source 'https://cdn.cocoapods.org/'",
+        podSourceForMode(productOptions.podSource),
+      ],
+      title: "Add Incode iOS podspec sources",
+    },
+    {
+      action: "android_repositories",
+      credentialsMode: "environment",
+      file: context.files.androidBuildGradle,
+      title: "Add Android Maven repositories and credential lookup",
+    },
+    {
+      action: "android_multidex",
+      file: context.files.androidAppBuildGradle,
+      title: "Enable Android multidex",
+    },
+    {
+      action: "android_permissions",
+      file: context.files.androidManifest,
+      permissions: [
+        "android.permission.CAMERA",
+        "android.permission.ACCESS_FINE_LOCATION",
+        "android.permission.ACCESS_COARSE_LOCATION",
+        "android.permission.RECORD_AUDIO",
+      ],
+      title: "Add Android runtime permissions",
+    },
+    {
+      action: "write_file",
+      content: createFlowConfigFile(productOptions),
+      file: "src/incodeFlow.ts",
+      title: `Generate ${productOptions.idv} ${productOptions.flowHandling} flow`,
+    },
+    {
+      action: "write_file",
+      content: createRuntimeConfigFile(productOptions),
+      file: "src/incodeRuntimeConfig.ts",
+      title: "Generate non-secret runtime defaults",
+    },
+    {
+      action: "write_file",
+      content: createExampleFile(),
+      file: "src/IncodeExample.ts",
+      title: "Create end-to-end and step-by-step onboarding example",
+    },
+  ];
+
+  if (featureDependencies.length > 0) {
+    changes.push({
+      action: "android_dependencies",
+      dependencies: featureDependencies,
+      file: context.files.androidAppBuildGradle,
+      title: "Add selected Incode Android feature dependencies",
+    });
+  }
+
+  if (
+    productOptions.githubToken ||
+    productOptions.githubUsername ||
+    productOptions.apiKey ||
+    productOptions.backendSessions
+  ) {
+    changes.push({
+      action: "write_file",
+      content: createLocalCredentialEnvFile(productOptions),
+      file: ".env.local",
+      title: "Write ignored local environment values",
+    });
+  }
+
+  if (productOptions.npmToken) {
+    changes.push({
+      action: "write_file",
+      content: createNpmrcFile(productOptions),
+      file: ".npmrc",
+      title: "Write ignored local NPM token",
+    });
+  }
+
+  if (context.files.infoPlist) {
+    changes.push({
+      action: "plist_strings",
+      entries: {
+        NSCameraUsageDescription:
+          "The Incode SDK uses the camera to verify identity documents and capture selfies.",
+        NSLocationWhenInUseUsageDescription:
+          "The Incode SDK can use location during geolocation verification steps.",
+        NSMicrophoneUsageDescription:
+          "The Incode SDK uses the microphone for video conference or video selfie flows.",
+      },
+      file: context.files.infoPlist,
+      title: "Add iOS privacy usage descriptions",
+    });
+  }
+
+  if (context.files.mainApplication) {
+    changes.push({
+      action: "main_application_multidex",
+      file: context.files.mainApplication,
+      title: "Use MultiDexApplication",
+    });
+  }
+
+  return {
+    changes,
+    productOptions,
+    root: context.root,
+    sdkDependency,
+    sdkSelection,
+  };
+}
+
+function yesNo(value) {
+  return value ? "yes" : "no";
+}
+
+function printPlan(context, plan, options) {
+  const product = plan.productOptions;
+  const featureDeps = [
+    product.videoStreaming ? "video-streaming" : "",
+    product.dynamicLocalization ? "dynamic-localization" : "",
+  ].filter(Boolean);
+
+  console.log(`Project: ${context.root}`);
+  console.log(`Platform: React Native`);
+  console.log(`React Native: ${context.reactNativeVersion || "unknown"}`);
+  console.log(`SDK source: ${plan.sdkSelection.source}`);
+  console.log(`SDK version: ${plan.sdkSelection.version}`);
+  console.log(`SDK variant: ${plan.sdkSelection.variant}`);
+  console.log(`SDK dependency: ${plan.sdkDependency}`);
+  console.log(`GitHub username: ${product.githubUsernameProvided ? "provided or in env" : "not provided"}`);
+  console.log(`GitHub token: ${product.githubTokenProvided ? "provided or in env" : "not provided"}`);
+  console.log(`NPM token: ${product.npmTokenProvided ? "provided or in env" : "not provided"}`);
+  console.log(`API URL: ${labelForApiUrl(product.apiUrl)} (${product.apiUrl})`);
+  console.log(`API key: ${product.apiKeyProvided ? "provided at prompt/CLI" : "not stored in source"}`);
+  console.log(`Backend sessions: ${yesNo(product.backendSessions)}${product.backendSessions ? " (no-api-key client)" : " (client API key mode)"}`);
+  if (product.backendSessions) {
+    console.log("Backend session endpoint: src/IncodeExample.ts appends /0/ to apiConfig.url.");
+    console.log("Backend session token: replace the demo UI input with your backend fetch, then pass session_token as sessionToken.");
+  }
+  console.log(`SDK configuration: ${product.sdkConfigMode}`);
+  if (product.sdkConfigMode === "online") {
+    console.log(`Dashboard flow URL: ${product.dashboardUrl || "not provided"}`);
+    console.log(`Dashboard environment: ${labelForApiUrl(product.apiUrl)}`);
+    console.log(`Configuration ID: ${product.configurationId || "not inferred"}`);
+    console.log("Dashboard flow config: will be fetched by API when the flow-config endpoint is connected.");
+  }
+  console.log(`IDV preset: ${product.idv}`);
+  console.log(`Flow handling: ${product.flowHandling}`);
+  console.log(`Default testMode: ${product.testMode}`);
+  console.log(`iOS podspec source: ${product.podSource}`);
+  console.log("Android credentials: GITHUB_USERNAME and GITHUB_TOKEN environment variables");
+  console.log(`Feature deps: ${featureDeps.join(", ") || "none"}`);
+  console.log("");
+  console.log(
+    "Secrets are never written to generated TypeScript, Gradle, Podfile, or README files.",
+  );
+  console.log(
+    "When --apply receives tokens, they are written only to ignored local files: .env.local and .npmrc.",
+  );
+  console.log("");
+  console.log(options.apply ? "Applying changes:" : "Planned changes:");
+
+  for (const change of plan.changes) {
+    console.log(`- ${change.title} (${change.file})`);
+  }
+
+  if (!options.apply) {
+    console.log("");
+    console.log("Dry run only. Re-run with `--apply` to update the project.");
+    console.log(
+      "Example: npx @incode-sdks/incode-integrate --version 9.14.0 --pod-source https --api-url demo --backend-sessions yes --sdk-config manual --idv standard-nfc --flow-handling step-by-step --apply",
+    );
+  }
+}
+
+async function run() {
+  const options = parseArgs(process.argv.slice(2));
+  const context = scanProject();
+  const productOptions = await chooseProductOptions(context, options);
+  const sdkSelection = chooseSdkSelection(productOptions);
+  const plan = generatePlan(context, sdkSelection, productOptions);
+
+  printPlan(context, plan, options);
+
+  if (!options.apply) {
+    return;
+  }
+
+  const results = applyPlan(plan);
+  console.log("");
+
+  for (const result of results) {
+    console.log(`${result.changed ? "updated" : "unchanged"} ${result.file}`);
+  }
+
+  if (results.some(result => result.file === ".env.local")) {
+    console.log("");
+    console.log("Before Android builds, load local credentials with: source .env.local");
+  }
+
+  console.log("");
+  console.log("Done. Run npm install, then cd ios && pod install when credentials are available.");
+}
+
+run().catch(error => {
+  console.error(error.message);
+  process.exitCode = 1;
+});