create-cmp-cli 0.2.0

package/src/bootstrap/checks.mjs

@@ -0,0 +1,283 @@
+// Per-dependency detection + install-command definitions for the toolchain.
+//
+// Each check is: { id, label, platforms, detect() -> {present, detail},
+//   installCommand(ctx) -> string|null, manual?: string }.
+// Detection uses real probes (which/--version/xcode-select/sdkmanager/appium…).
+// installCommand returns the EXACT command to run; if null, the dep can't be
+// auto-installed (e.g. Xcode → App Store) and `manual` explains the step.
+
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { probe, which } from "./exec.mjs";
+
+const isMac = process.platform === "darwin";
+const isLinux = process.platform === "linux";
+
+function brewPrefixCommand(pkg) {
+  if (isMac) return `brew install ${pkg}`;
+  if (isLinux) return null;
+  return null;
+}
+
+function androidHome() {
+  return (
+    process.env.ANDROID_HOME ||
+    process.env.ANDROID_SDK_ROOT ||
+    path.join(os.homedir(), "Library", "Android", "sdk")
+  );
+}
+
+function sdkmanagerPath() {
+  const home = androidHome();
+  const candidates = [
+    path.join(home, "cmdline-tools", "latest", "bin", "sdkmanager"),
+    path.join(home, "cmdline-tools", "bin", "sdkmanager"),
+    path.join(home, "tools", "bin", "sdkmanager"),
+  ];
+  for (const c of candidates) if (fs.existsSync(c)) return c;
+  return which("sdkmanager");
+}
+
+function avdmanagerPath() {
+  const home = androidHome();
+  const candidates = [
+    path.join(home, "cmdline-tools", "latest", "bin", "avdmanager"),
+    path.join(home, "cmdline-tools", "bin", "avdmanager"),
+  ];
+  for (const c of candidates) if (fs.existsSync(c)) return c;
+  return which("avdmanager");
+}
+
+function emulatorPath() {
+  const home = androidHome();
+  const c = path.join(home, "emulator", "emulator");
+  if (fs.existsSync(c)) return c;
+  return which("emulator");
+}
+
+export const checks = [
+  {
+    id: "node",
+    label: "Node.js (≥18)",
+    platforms: ["darwin", "linux", "win32"],
+    detect() {
+      const r = probe("node", ["--version"]);
+      if (!r.ok) return { present: false, detail: "not found" };
+      const major = parseInt(r.stdout.replace(/^v/, "").split(".")[0], 10);
+      return { present: major >= 18, detail: r.stdout + (major >= 18 ? "" : " (need ≥18)") };
+    },
+    installCommand: () => (isMac ? "brew install node" : "see https://nodejs.org / use nvm"),
+  },
+  {
+    id: "jdk",
+    label: "JDK 17 (Temurin)",
+    platforms: ["darwin", "linux"],
+    detect() {
+      const r = probe("javac", ["-version"]);
+      const r2 = r.ok ? r : probe("java", ["-version"]);
+      const out = (r2.stdout || r2.stderr || "").trim();
+      const m = out.match(/(\d+)(\.\d+)?/);
+      const major = m ? parseInt(m[1], 10) : 0;
+      if (!out) return { present: false, detail: "not found" };
+      return { present: major >= 17, detail: out.split("\n")[0] };
+    },
+    installCommand: () =>
+      isMac ? "brew install --cask temurin@17" : "sdk install java 17.0.13-tem  # (sdkman)",
+  },
+  {
+    id: "android-cmdline-tools",
+    label: "Android cmdline-tools (sdkmanager)",
+    platforms: ["darwin", "linux"],
+    detect() {
+      const sm = sdkmanagerPath();
+      return sm
+        ? { present: true, detail: sm }
+        : { present: false, detail: `not found under ${androidHome()}` };
+    },
+    installCommand: () =>
+      isMac
+        ? "brew install --cask android-commandlinetools"
+        : "download cmdline-tools from developer.android.com and unzip into $ANDROID_HOME/cmdline-tools/latest",
+  },
+  {
+    id: "android-platform",
+    label: "Android SDK platform + build-tools + platform-tools",
+    platforms: ["darwin", "linux"],
+    detect() {
+      const sm = sdkmanagerPath();
+      if (!sm) return { present: false, detail: "sdkmanager missing" };
+      const r = probe(sm, ["--list_installed"]);
+      const listing = r.ok ? r.stdout : probe(sm, ["--list"]).stdout;
+      const hasPlatform = /platforms;android-\d+/.test(listing);
+      const hasBuildTools = /build-tools;/.test(listing);
+      const hasPlatformTools = /platform-tools/.test(listing) || !!which("adb");
+      const present = hasPlatform && hasBuildTools && hasPlatformTools;
+      return {
+        present,
+        detail: present ? "platform+build-tools+platform-tools present" : "missing SDK components",
+      };
+    },
+    installCommand: () => {
+      const sm = sdkmanagerPath() || "sdkmanager";
+      return `"${sm}" "platform-tools" "platforms;android-35" "build-tools;35.0.0"`;
+    },
+  },
+  {
+    id: "android-system-image",
+    label: "Android system image",
+    platforms: ["darwin", "linux"],
+    detect() {
+      const sm = sdkmanagerPath();
+      if (!sm) return { present: false, detail: "sdkmanager missing" };
+      const r = probe(sm, ["--list_installed"]);
+      const listing = r.ok ? r.stdout : "";
+      const present = /system-images;android-\d+;/.test(listing);
+      return { present, detail: present ? "system image present" : "no system image installed" };
+    },
+    installCommand: () => {
+      const sm = sdkmanagerPath() || "sdkmanager";
+      const arch = process.arch === "arm64" ? "arm64-v8a" : "x86_64";
+      return `"${sm}" "system-images;android-35;google_apis;${arch}"`;
+    },
+  },
+  {
+    id: "android-avd",
+    label: "Bootable AVD",
+    platforms: ["darwin", "linux"],
+    detect() {
+      const em = emulatorPath();
+      if (em) {
+        const r = probe(em, ["-list-avds"]);
+        if (r.ok && r.stdout.trim().length > 0) {
+          return { present: true, detail: r.stdout.split("\n").join(", ") };
+        }
+      }
+      // Fallback: look for ~/.android/avd/*.avd
+      const avdDir = path.join(os.homedir(), ".android", "avd");
+      if (fs.existsSync(avdDir)) {
+        const avds = fs.readdirSync(avdDir).filter((f) => f.endsWith(".avd"));
+        if (avds.length) return { present: true, detail: avds.join(", ") };
+      }
+      return { present: false, detail: "no AVD found" };
+    },
+    installCommand: () => {
+      const am = avdmanagerPath() || "avdmanager";
+      const arch = process.arch === "arm64" ? "arm64-v8a" : "x86_64";
+      return `echo no | "${am}" create avd -n cmp_pixel -k "system-images;android-35;google_apis;${arch}" --device pixel_6`;
+    },
+  },
+  {
+    id: "adb",
+    label: "adb (platform-tools)",
+    platforms: ["darwin", "linux", "win32"],
+    detect() {
+      const adb = which("adb") || (() => {
+        const c = path.join(androidHome(), "platform-tools", "adb");
+        return fs.existsSync(c) ? c : null;
+      })();
+      return adb ? { present: true, detail: adb } : { present: false, detail: "adb not on PATH" };
+    },
+    installCommand: () => {
+      const sm = sdkmanagerPath() || "sdkmanager";
+      return `"${sm}" "platform-tools"`;
+    },
+  },
+  {
+    id: "xcode",
+    label: "Xcode + Command Line Tools",
+    platforms: ["darwin"],
+    detect() {
+      const r = probe("xcode-select", ["-p"]);
+      if (!r.ok || !r.stdout) return { present: false, detail: "xcode-select path not set" };
+      const isFullXcode = /Xcode\.app/.test(r.stdout);
+      return {
+        present: isFullXcode,
+        detail: r.stdout + (isFullXcode ? "" : " (only CLT — full Xcode needed for iOS build)"),
+      };
+    },
+    // Xcode itself can't be CLI-installed.
+    installCommand: () => null,
+    manual:
+      "Install Xcode from the App Store, then run `sudo xcode-select -s /Applications/Xcode.app` and `sudo xcodebuild -license accept`.",
+  },
+  {
+    id: "cocoapods",
+    label: "CocoaPods",
+    platforms: ["darwin"],
+    detect() {
+      const r = probe("pod", ["--version"]);
+      return r.ok
+        ? { present: true, detail: `pod ${r.stdout}` }
+        : { present: false, detail: "not found" };
+    },
+    installCommand: () => "brew install cocoapods",
+  },
+  {
+    id: "xcodegen",
+    label: "XcodeGen",
+    platforms: ["darwin"],
+    detect() {
+      const r = probe("xcodegen", ["--version"]);
+      return r.ok
+        ? { present: true, detail: r.stdout.split("\n")[0] }
+        : { present: false, detail: "not found" };
+    },
+    installCommand: () => "brew install xcodegen",
+  },
+  {
+    id: "appium",
+    label: "Appium 3.x",
+    platforms: ["darwin", "linux"],
+    detect() {
+      const r = probe("appium", ["--version"]);
+      if (!r.ok) return { present: false, detail: "not found" };
+      const major = parseInt(r.stdout.split(".")[0], 10);
+      return { present: major >= 3, detail: `appium ${r.stdout}${major >= 3 ? "" : " (need 3.x)"}` };
+    },
+    installCommand: () => "npm install -g appium@latest",
+  },
+  {
+    id: "appium-uiautomator2",
+    label: "Appium driver: uiautomator2 (Android)",
+    platforms: ["darwin", "linux"],
+    detect() {
+      const r = probe("appium", ["driver", "list", "--installed"]);
+      const out = (r.stdout || r.stderr || "").toLowerCase();
+      const present = out.includes("uiautomator2");
+      return { present, detail: present ? "installed" : "not installed" };
+    },
+    installCommand: () => "appium driver install uiautomator2",
+  },
+  {
+    id: "appium-xcuitest",
+    label: "Appium driver: xcuitest (iOS)",
+    platforms: ["darwin"],
+    detect() {
+      const r = probe("appium", ["driver", "list", "--installed"]);
+      const out = (r.stdout || r.stderr || "").toLowerCase();
+      const present = out.includes("xcuitest");
+      return { present, detail: present ? "installed" : "not installed" };
+    },
+    installCommand: () => "appium driver install xcuitest",
+  },
+];
+
+/**
+ * Filter checks to those relevant to the current OS, optionally Android-only.
+ * @param {object} opts
+ * @param {boolean} [opts.iosWanted] include iOS-only checks (macOS only)
+ * @returns {Array}
+ */
+export function checksForHost({ iosWanted = true } = {}) {
+  const plat = process.platform;
+  return checks.filter((c) => {
+    if (!c.platforms.includes(plat)) return false;
+    // iOS-specific checks are skipped off macOS or when iOS not wanted.
+    const iosOnly = c.platforms.length === 1 && c.platforms[0] === "darwin";
+    if (iosOnly && (!isMac || !iosWanted)) return false;
+    return true;
+  });
+}
+
+export const hostInfo = { isMac, isLinux, androidHome };

package/src/bootstrap/exec.mjs

@@ -0,0 +1,90 @@
+// Shared command-detection + consent-gated install helpers for the bootstrap
+// toolchain installer. Detection is real (which/--version probes); every
+// mutating install command is consent-gated and dry-runnable.
+
+import { spawnSync, spawn } from "node:child_process";
+import readline from "node:readline";
+
+/**
+ * Run a command and capture output synchronously (for detection probes).
+ * Never throws — returns {ok, code, stdout, stderr}.
+ * @param {string} cmd
+ * @param {string[]} args
+ * @returns {{ok:boolean, code:number, stdout:string, stderr:string}}
+ */
+export function probe(cmd, args = []) {
+  try {
+    const r = spawnSync(cmd, args, { encoding: "utf8", timeout: 20000 });
+    return {
+      ok: r.status === 0,
+      code: r.status ?? 1,
+      stdout: (r.stdout || "").trim(),
+      stderr: (r.stderr || "").trim(),
+    };
+  } catch {
+    return { ok: false, code: 127, stdout: "", stderr: "" };
+  }
+}
+
+/**
+ * Is a binary on PATH?
+ * @param {string} bin
+ * @returns {string|null} resolved path or null
+ */
+export function which(bin) {
+  const finder = process.platform === "win32" ? "where" : "which";
+  const r = probe(finder, [bin]);
+  if (r.ok && r.stdout) return r.stdout.split("\n")[0].trim();
+  return null;
+}
+
+/**
+ * Ask the user for yes/no consent. In --yes mode, auto-approves.
+ * @param {string} question
+ * @param {object} opts
+ * @param {boolean} opts.assumeYes
+ * @returns {Promise<boolean>}
+ */
+export async function consent(question, { assumeYes = false } = {}) {
+  if (assumeYes) {
+    process.stdout.write(`${question} ${"(auto-yes)"}\n`);
+    return true;
+  }
+  if (!process.stdin.isTTY) {
+    // Non-interactive without --yes: decline mutating actions.
+    process.stdout.write(`${question} (no TTY, declining — pass --yes to auto-approve)\n`);
+    return false;
+  }
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const answer = await new Promise((resolve) => {
+    rl.question(`${question} [y/N] `, (a) => resolve(a.trim().toLowerCase()));
+  });
+  rl.close();
+  return answer === "y" || answer === "yes";
+}
+
+/**
+ * Run an install command, consent-gated and dry-runnable.
+ * @param {object} params
+ * @param {string} params.command human/shell install command
+ * @param {boolean} params.assumeYes
+ * @param {boolean} params.dryRun
+ * @returns {Promise<{ran:boolean, code:number, approved:boolean}>}
+ */
+export async function runInstall({ command, assumeYes, dryRun }) {
+  if (dryRun) {
+    process.stdout.write(`    [dry-run] would run: ${command}\n`);
+    return { ran: false, code: 0, approved: false };
+  }
+  const approved = await consent(`    Run install: \`${command}\`?`, { assumeYes });
+  if (!approved) {
+    process.stdout.write(`    skipped (not approved)\n`);
+    return { ran: false, code: 0, approved: false };
+  }
+  const code = await new Promise((resolve) => {
+    const child = spawn(command, { shell: true, stdio: "inherit", env: process.env });
+    child.on("close", (c) => resolve(c ?? 1));
+    child.on("error", () => resolve(127));
+  });
+  return { ran: true, code, approved: true };
+}

package/src/commands/clean.mjs

@@ -0,0 +1,195 @@
+// `create-cmp clean` — report-then-clean cache hygiene (disk-space failures
+// are a real KMP build-killer).
+//
+//   create-cmp clean [--target-dir .] [--yes] [--dry-run]
+//
+// What it does:
+//   - ~/.konan: reports total size; deletes ONLY clearly-stale toolchains —
+//     kotlin-native(-prebuilt) dirs whose version ≠ the project's kotlin
+//     version (no known project kotlin → report only).
+//   - project: deletes Gradle `build/` dirs (only those next to a
+//     build.gradle[.kts]) and the root `.gradle/` dir.
+//   - ~/.gradle/caches: size REPORT ONLY — never auto-deleted; the manual
+//     command is printed instead.
+//   - Sizes are shown before and after; every deletion is consent-gated
+//     (--yes skips the prompt, --dry-run never deletes).
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+import { colors, ok, warn } from "../lib/log.mjs";
+import { probe, consent } from "../bootstrap/exec.mjs";
+import { selectStaleKonan, selectProjectCleanDirs } from "../lib/clean.mjs";
+import { formatBytes } from "../lib/project-doctor.mjs";
+import { parseVersions } from "../lib/toml.mjs";
+
+function duBytes(p) {
+  if (!fs.existsSync(p)) return null;
+  const r = probe("du", ["-sk", p]);
+  if (!r.ok) return null;
+  const kb = parseInt(r.stdout.split(/\s+/)[0], 10);
+  return Number.isFinite(kb) ? kb * 1024 : null;
+}
+
+function listProjectTree(projectDir) {
+  const dirs = [];
+  const files = [];
+  const walk = (dir, rel, depth) => {
+    if (depth > 4) return; // Gradle module build dirs live shallow
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      const r = rel ? `${rel}/${e.name}` : e.name;
+      if (e.isDirectory()) {
+        dirs.push(r);
+        // don't descend into the heavy dirs we might delete, or vendored trees
+        if (e.name === "build" || e.name === ".gradle" || e.name === "node_modules" || e.name === ".git") continue;
+        walk(path.join(dir, e.name), r, depth + 1);
+      } else if (e.isFile()) {
+        files.push(r);
+      }
+    }
+  };
+  walk(projectDir, "", 0);
+  return { dirs, files };
+}
+
+function projectKotlinVersion(projectDir) {
+  try {
+    const toml = fs.readFileSync(path.join(projectDir, "gradle", "libs.versions.toml"), "utf8");
+    const kotlin = parseVersions(toml).get("kotlin");
+    return kotlin ? kotlin.value : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * @param {Record<string,string|boolean>} flags
+ * @param {string|undefined} positional optional target dir positional
+ */
+export async function runClean(flags, positional) {
+  const targetDir =
+    (typeof flags["target-dir"] === "string" && flags["target-dir"]) || positional || ".";
+  const projectDir = path.resolve(targetDir);
+  const dryRun = flags["dry-run"] === true;
+
+  process.stdout.write(`\n${colors.bold("create-cmp clean")} — cache & build-output hygiene\n\n`);
+
+  // ---- gather the plan ------------------------------------------------------
+  const plan = []; // {label, absPath, bytes}
+
+  // ~/.konan
+  const konanDir = path.join(os.homedir(), ".konan");
+  const konanBytes = duBytes(konanDir);
+  const kotlinVersion = projectKotlinVersion(projectDir);
+  if (konanBytes !== null) {
+    process.stdout.write(
+      `${colors.bold("~/.konan")}: ${formatBytes(konanBytes)}` +
+        (kotlinVersion
+          ? colors.dim(` (project kotlin: ${kotlinVersion})`)
+          : colors.dim(" (no project kotlin version found — nothing is provably stale)")) +
+        "\n"
+    );
+    let entries = [];
+    try {
+      entries = fs.readdirSync(konanDir).filter((e) => {
+        try {
+          return fs.statSync(path.join(konanDir, e)).isDirectory();
+        } catch {
+          return false;
+        }
+      });
+    } catch {
+      /* unreadable — skip */
+    }
+    const { stale, kept } = selectStaleKonan(entries, kotlinVersion);
+    for (const name of stale) {
+      const abs = path.join(konanDir, name);
+      plan.push({ label: `~/.konan/${name} (stale toolchain)`, absPath: abs, bytes: duBytes(abs) });
+    }
+    for (const k of kept) {
+      process.stdout.write(`  ${colors.dim(`keep ${k.name} — ${k.reason}`)}\n`);
+    }
+  } else {
+    process.stdout.write(`${colors.bold("~/.konan")}: ${colors.dim("not present")}\n`);
+  }
+
+  // project build outputs
+  if (fs.existsSync(projectDir)) {
+    const tree = listProjectTree(projectDir);
+    const cleanDirs = selectProjectCleanDirs(tree);
+    for (const rel of cleanDirs) {
+      const abs = path.join(projectDir, rel);
+      plan.push({ label: `${path.basename(projectDir)}/${rel}`, absPath: abs, bytes: duBytes(abs) });
+    }
+    if (cleanDirs.length === 0) {
+      process.stdout.write(`${colors.bold("project")}: ${colors.dim(`no Gradle build/.gradle dirs under ${projectDir}`)}\n`);
+    }
+  }
+
+  // ~/.gradle/caches — REPORT ONLY
+  const gradleCaches = path.join(os.homedir(), ".gradle", "caches");
+  const gradleCachesBytes = duBytes(gradleCaches);
+  if (gradleCachesBytes !== null) {
+    process.stdout.write(
+      `${colors.bold("~/.gradle/caches")}: ${formatBytes(gradleCachesBytes)} ` +
+        colors.dim("(report only — never auto-deleted; reclaim manually with: rm -rf ~/.gradle/caches)") +
+        "\n"
+    );
+  }
+
+  if (plan.length === 0) {
+    ok("Nothing safe to clean.");
+    process.exit(0);
+  }
+
+  // ---- report the plan ------------------------------------------------------
+  const totalBytes = plan.reduce((s, p) => s + (p.bytes ?? 0), 0);
+  process.stdout.write(`\n${colors.bold("Would delete")} (${formatBytes(totalBytes)} total):\n`);
+  for (const p of plan) {
+    process.stdout.write(
+      `  ${colors.red("×")} ${p.label} ${colors.dim(p.bytes !== null ? `(${formatBytes(p.bytes)})` : "")}\n`
+    );
+  }
+
+  if (dryRun) {
+    process.stdout.write(`\n${colors.yellow("Dry run")} — nothing deleted.\n`);
+    process.exit(0);
+  }
+
+  const approved = await consent(`\nDelete the ${plan.length} item(s) above?`, {
+    assumeYes: flags.yes === true,
+  });
+  if (!approved) {
+    warn("Not approved — nothing deleted.");
+    process.exit(0);
+  }
+
+  // ---- delete + after sizes ---------------------------------------------------
+  let freed = 0;
+  for (const p of plan) {
+    try {
+      fs.rmSync(p.absPath, { recursive: true, force: true });
+      freed += p.bytes ?? 0;
+      ok(`deleted ${p.label}`);
+    } catch (err) {
+      warn(`could not delete ${p.label}: ${err.message}`);
+    }
+  }
+
+  const konanAfter = duBytes(konanDir);
+  process.stdout.write(
+    `\n${colors.green("Done.")} Freed ~${formatBytes(freed)}.` +
+      (konanBytes !== null && konanAfter !== null
+        ? ` ~/.konan: ${formatBytes(konanBytes)} → ${formatBytes(konanAfter)}.`
+        : "") +
+      "\n"
+  );
+  process.exit(0);
+}