@incode-sdks/incode-integrate 0.1.0

package/executor.js

@@ -0,0 +1,301 @@
+const fs = require("fs");
+const path = require("path");
+
+function readText(root, file) {
+  return fs.readFileSync(path.join(root, file), "utf8");
+}
+
+function writeText(root, file, content) {
+  const filePath = path.join(root, file);
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, content);
+}
+
+function formatJson(value) {
+  return `${JSON.stringify(value, null, 2)}\n`;
+}
+
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function upsertJsonDependency(content, name, version) {
+  const packageJson = JSON.parse(content);
+  packageJson.dependencies = packageJson.dependencies || {};
+
+  if (packageJson.dependencies[name] === version) {
+    return content;
+  }
+
+  packageJson.dependencies[name] = version;
+  return formatJson(packageJson);
+}
+
+function ensurePodSources(content, sources) {
+  const desiredIncodeSource = sources.find(source =>
+    source.includes("IncdDistributionPodspecs.git"),
+  );
+  let next = content
+    .split("\n")
+    .filter(line => {
+      const isIncodePodspecSource = line.includes("IncdDistributionPodspecs.git");
+      return !isIncodePodspecSource || line.trim() === desiredIncodeSource;
+    })
+    .join("\n");
+
+  for (const source of sources.slice().reverse()) {
+    if (!next.includes(source)) {
+      next = `${source}\n${next}`;
+    }
+  }
+
+  return next;
+}
+
+function ensurePlistStrings(content, entries) {
+  let next = content;
+
+  for (const [key, value] of Object.entries(entries)) {
+    const pattern = new RegExp(
+      `<key>${escapeRegExp(key)}</key>\\s*<string>[\\s\\S]*?</string>`,
+      "m",
+    );
+    const replacement = `<key>${key}</key>\n\t<string>${value}</string>`;
+
+    if (pattern.test(next)) {
+      next = next.replace(pattern, replacement);
+      continue;
+    }
+
+    next = next.replace(/\n<\/dict>/, `\n\t${replacement}\n</dict>`);
+  }
+
+  return next;
+}
+
+function ensureAndroidPermissions(content, permissions) {
+  let next = content;
+
+  for (const permission of permissions) {
+    const line = `<uses-permission android:name="${permission}" />`;
+    if (!next.includes(line)) {
+      next = next.replace(/\n\s*<application/, `\n    ${line}\n\n    <application`);
+    }
+  }
+
+  return next;
+}
+
+function createAndroidRepositoryBlock(credentialsMode) {
+  const credentialBlocks = {
+    environment: `            credentials {
+                username = System.getenv("GITHUB_USERNAME")
+                password = System.getenv("GITHUB_TOKEN")
+            }`,
+  };
+
+  return `
+
+// Incode SDK repositories start
+allprojects {
+    repositories {
+        maven { url "https://jitpack.io" }
+        maven {
+            url = uri("https://maven.pkg.github.com/Incode-Technologies-Example-Repos/android-omni-packages")
+${credentialBlocks[credentialsMode] || credentialBlocks.environment}
+        }
+    }
+}
+// Incode SDK repositories end
+`;
+}
+
+function replaceEnclosingAllProjectsBlock(content, replacement) {
+  const repoIndex = content.indexOf("android-omni-packages");
+  if (repoIndex < 0) {
+    return `${content.trimEnd()}${replacement}`;
+  }
+
+  const start = content.lastIndexOf("allprojects", repoIndex);
+  if (start < 0) {
+    return content;
+  }
+
+  const openBrace = content.indexOf("{", start);
+  if (openBrace < 0) {
+    return content;
+  }
+
+  let depth = 0;
+  for (let index = openBrace; index < content.length; index += 1) {
+    if (content[index] === "{") {
+      depth += 1;
+    }
+
+    if (content[index] === "}") {
+      depth -= 1;
+    }
+
+    if (depth === 0) {
+      const before = content.slice(0, start).trimEnd();
+      const after = content.slice(index + 1).replace(
+        /^\s*\/\/ Incode SDK repositories end\s*/,
+        "",
+      );
+      return `${before}${replacement}${after}`;
+    }
+  }
+
+  return content;
+}
+
+function ensureAndroidRepositories(content, credentialsMode) {
+  const block = createAndroidRepositoryBlock(credentialsMode);
+  const markedPattern =
+    /\n*\/\/ Incode SDK repositories start[\s\S]*?\/\/ Incode SDK repositories end\n*/;
+
+  if (markedPattern.test(content)) {
+    return content.replace(markedPattern, block);
+  }
+
+  return replaceEnclosingAllProjectsBlock(content, block);
+}
+
+function ensureAndroidMultidex(content) {
+  let next = content;
+
+  if (!next.includes("multiDexEnabled true")) {
+    next = next.replace(
+      /(versionName\s+["'][^"']+["']\s*)/,
+      `$1        multiDexEnabled true\n`,
+    );
+  }
+
+  if (!next.includes("androidx.multidex:multidex") && !next.includes("com.android.support:multidex")) {
+    next = next.replace(
+      /^(\s*implementation\(["']com\.facebook\.react:react-android["']\)\s*)$/m,
+      `$1\n    implementation("androidx.multidex:multidex:2.0.1")`,
+    );
+  }
+
+  return next;
+}
+
+function ensureAndroidDependencies(content, dependencies) {
+  let next = content;
+
+  for (const dependency of dependencies) {
+    if (next.includes(dependency.notIfIncludes || dependency.notation)) {
+      continue;
+    }
+
+    const line = `    implementation("${dependency.notation}")`;
+    next = next.replace(
+      /^(\s*implementation\(["']com\.facebook\.react:react-android["']\)\s*)$/m,
+      `$1\n${line}`,
+    );
+  }
+
+  return next;
+}
+
+function ensureGitignoreEntries(content, entries) {
+  let next = content.trimEnd();
+
+  for (const entry of entries) {
+    const hasEntry = next
+      .split("\n")
+      .map(line => line.trim())
+      .includes(entry);
+
+    if (!hasEntry) {
+      next = `${next}\n${entry}`;
+    }
+  }
+
+  return `${next}\n`;
+}
+
+function ensureMainApplicationMultidex(content) {
+  if (content.includes("MultiDexApplication()")) {
+    return content;
+  }
+
+  let next = content;
+
+  if (next.includes("import android.app.Application")) {
+    next = next.replace("import android.app.Application", "import androidx.multidex.MultiDexApplication");
+  } else if (!next.includes("import androidx.multidex.MultiDexApplication")) {
+    next = next.replace(/\nimport /, "\nimport androidx.multidex.MultiDexApplication\nimport ");
+  }
+
+  next = next.replace(": Application(), ReactApplication", ": MultiDexApplication(), ReactApplication");
+  return next;
+}
+
+function applyTransform(root, change, transform) {
+  const before = readText(root, change.file);
+  const after = transform(before);
+
+  if (before !== after) {
+    writeText(root, change.file, after);
+    return { changed: true, file: change.file, title: change.title };
+  }
+
+  return { changed: false, file: change.file, title: change.title };
+}
+
+function applyChange(root, change) {
+  switch (change.action) {
+    case "json_dependency":
+      return applyTransform(root, change, content =>
+        upsertJsonDependency(content, change.name, change.version),
+      );
+    case "pod_sources":
+      return applyTransform(root, change, content => ensurePodSources(content, change.sources));
+    case "plist_strings":
+      return applyTransform(root, change, content => ensurePlistStrings(content, change.entries));
+    case "android_permissions":
+      return applyTransform(root, change, content =>
+        ensureAndroidPermissions(content, change.permissions),
+      );
+    case "android_repositories":
+      return applyTransform(root, change, content =>
+        ensureAndroidRepositories(content, change.credentialsMode),
+      );
+    case "android_multidex":
+      return applyTransform(root, change, ensureAndroidMultidex);
+    case "android_dependencies":
+      return applyTransform(root, change, content =>
+        ensureAndroidDependencies(content, change.dependencies),
+      );
+    case "gitignore_entries":
+      return applyTransform(root, change, content =>
+        ensureGitignoreEntries(content, change.entries),
+      );
+    case "main_application_multidex":
+      return applyTransform(root, change, ensureMainApplicationMultidex);
+    case "write_file": {
+      const before = fs.existsSync(path.join(root, change.file))
+        ? readText(root, change.file)
+        : "";
+
+      if (before === change.content) {
+        return { changed: false, file: change.file, title: change.title };
+      }
+
+      writeText(root, change.file, change.content);
+      return { changed: true, file: change.file, title: change.title };
+    }
+    default:
+      throw new Error(`Unknown change action: ${change.action}`);
+  }
+}
+
+function applyPlan(plan) {
+  return plan.changes.map(change => applyChange(plan.root, change));
+}
+
+module.exports = {
+  applyPlan,
+};

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@incode-sdks/incode-integrate",
+  "version": "0.1.0",
+  "description": "CLI integration auditor and fixer for adding the Incode React Native SDK to client apps.",
+  "main": "agent.js",
+  "bin": {
+    "incode-integrate": "agent.js"
+  },
+  "files": [
+    "agent.js",
+    "executor.js",
+    "scanner.js",
+    "README.md"
+  ],
+  "scripts": {
+    "apply": "node agent.js --apply",
+    "plan": "node agent.js",
+    "pack:dry": "npm pack --dry-run",
+    "test": "node --check agent.js && node --check executor.js && node --check scanner.js && node agent.js --yes"
+  },
+  "keywords": [
+    "incode",
+    "react-native",
+    "identity-verification",
+    "sdk",
+    "cli"
+  ],
+  "author": "Incode",
+  "license": "UNLICENSED",
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/scanner.js

@@ -0,0 +1,120 @@
+const fs = require("fs");
+const path = require("path");
+
+const SDK_PACKAGE = "@incode-sdks/react-native-incode-sdk";
+
+function readTextIfExists(filePath) {
+  return fs.existsSync(filePath) ? fs.readFileSync(filePath, "utf8") : "";
+}
+
+function readJsonIfExists(filePath) {
+  const content = readTextIfExists(filePath);
+  return content ? JSON.parse(content) : {};
+}
+
+function findProjectRoot(start = path.resolve(__dirname, "..")) {
+  let current = start;
+
+  while (current !== path.dirname(current)) {
+    const packageJson = path.join(current, "package.json");
+    const iosDir = path.join(current, "ios");
+    const androidDir = path.join(current, "android");
+
+    if (fs.existsSync(packageJson) && fs.existsSync(iosDir) && fs.existsSync(androidDir)) {
+      return current;
+    }
+
+    current = path.dirname(current);
+  }
+
+  throw new Error("Could not find a React Native app root with package.json, ios, and android.");
+}
+
+function toRelative(root, filePath) {
+  return path.relative(root, filePath).split(path.sep).join("/");
+}
+
+function findInfoPlist(root) {
+  const iosDir = path.join(root, "ios");
+  if (!fs.existsSync(iosDir)) {
+    return "";
+  }
+
+  for (const entry of fs.readdirSync(iosDir, { withFileTypes: true })) {
+    if (!entry.isDirectory() || entry.name.endsWith(".xcodeproj") || entry.name.endsWith(".xcworkspace")) {
+      continue;
+    }
+
+    const plist = path.join(iosDir, entry.name, "Info.plist");
+    if (fs.existsSync(plist)) {
+      return toRelative(root, plist);
+    }
+  }
+
+  return "";
+}
+
+function findMainApplication(root) {
+  const sourceRoot = path.join(root, "android", "app", "src", "main");
+  const stack = [sourceRoot];
+
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (!current || !fs.existsSync(current)) {
+      continue;
+    }
+
+    for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
+      const fullPath = path.join(current, entry.name);
+
+      if (entry.isDirectory()) {
+        stack.push(fullPath);
+        continue;
+      }
+
+      if (entry.name === "MainApplication.kt" || entry.name === "MainApplication.java") {
+        return toRelative(root, fullPath);
+      }
+    }
+  }
+
+  return "";
+}
+
+function scanProject(root = findProjectRoot()) {
+  const packagePath = path.join(root, "package.json");
+  const packageJson = readJsonIfExists(packagePath);
+  const dependencies = packageJson.dependencies || {};
+  const devDependencies = packageJson.devDependencies || {};
+  const reactNativeVersion = dependencies["react-native"] || devDependencies["react-native"] || "";
+  const sdkDependency = dependencies[SDK_PACKAGE] || "";
+  const files = {
+    androidAppBuildGradle: "android/app/build.gradle",
+    androidBuildGradle: "android/build.gradle",
+    androidManifest: "android/app/src/main/AndroidManifest.xml",
+    infoPlist: findInfoPlist(root),
+    incodeFlow: "src/incodeFlow.ts",
+    incodeRuntimeConfig: "src/incodeRuntimeConfig.ts",
+    mainApplication: findMainApplication(root),
+    packageJson: "package.json",
+    podfile: "ios/Podfile",
+  };
+
+  return {
+    files,
+    packageJson,
+    reactNativeVersion,
+    root,
+    sdkDependency,
+    sdkInstalled: Boolean(sdkDependency),
+    texts: Object.fromEntries(
+      Object.entries(files).map(([key, file]) => [key, file ? readTextIfExists(path.join(root, file)) : ""]),
+    ),
+  };
+}
+
+module.exports = {
+  SDK_PACKAGE,
+  findProjectRoot,
+  scanProject,
+};