path-terminal-init 0.2.0

package/dist/cli.js

@@ -0,0 +1,725 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var import_commander = require("commander");
+var import_chalk = __toESM(require("chalk"));
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var readline = __toESM(require("readline"));
+var import_child_process = require("child_process");
+var import_ora = __toESM(require("ora"));
+const SDK_GITHUB_URL = "https://github.com/keyman12/path-terminal-sdk";
+const ANDROID_SDK_GITHUB_URL = "https://github.com/keyman12/path-terminal-sdk-android";
+const SDK_VERSION = "0.1.0";
+const ANDROID_SDK_JITPACK_VERSION = "v1.4";
+const ANDROID_SDK_JITPACK_GROUP = "com.github.keyman12.path-terminal-sdk-android";
+const MCP_SERVER_URL = "https://mcp.path2ai.tech/sse";
+const RULES_FETCH_URL = "https://mcp.path2ai.tech/rules";
+const ANDROID_RULES_FETCH_URL = "https://mcp.path2ai.tech/rules/android";
+const WINDOWS11_RULES_FETCH_URL = "https://mcp.path2ai.tech/rules/windows11";
+const WINDOWS10_RULES_FETCH_URL = "https://mcp.path2ai.tech/rules/windows10";
+const RULES_SOURCE = path.join(__dirname, "../rules/ios/path-integration.mdc");
+const ANDROID_RULES_SOURCE = path.join(__dirname, "../rules/android/path-integration-android.mdc");
+const WINDOWS11_RULES_SOURCE = path.join(__dirname, "../rules/windows-11/path-integration-windows11.mdc");
+const WINDOWS10_RULES_SOURCE = path.join(__dirname, "../rules/windows-10/path-integration-windows10.mdc");
+const WINDOWS_SDK_REPO = "Path-terminal-sdk-windows11";
+function ask(question) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+function findXcodeProject(dir) {
+  const isXcodeArtifact = (e) => e.endsWith(".xcodeproj") || e.endsWith(".xcworkspace");
+  const entries = fs.readdirSync(dir);
+  const proj = entries.find(isXcodeArtifact);
+  if (proj) return path.join(dir, proj);
+  for (const entry of entries) {
+    if (entry.startsWith(".")) continue;
+    const sub = path.join(dir, entry);
+    try {
+      if (fs.statSync(sub).isDirectory()) {
+        const subEntries = fs.readdirSync(sub);
+        const subProj = subEntries.find(isXcodeArtifact);
+        if (subProj) return path.join(sub, subProj);
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function findPackageSwift(dir) {
+  const p = path.join(dir, "Package.swift");
+  return fs.existsSync(p) ? p : null;
+}
+function hasSDKDependency(packageSwift) {
+  const content = fs.readFileSync(packageSwift, "utf-8");
+  return content.includes("path-terminal-sdk") || content.includes("PathTerminalSDK");
+}
+function hasXcodeProjectSDKDependency(xcodeProject) {
+  const resolvedPaths = [
+    path.join(xcodeProject, "project.xcworkspace", "xcshareddata", "swiftpm", "Package.resolved"),
+    path.join(xcodeProject, "xcshareddata", "swiftpm", "Package.resolved")
+  ];
+  for (const p of resolvedPaths) {
+    if (fs.existsSync(p)) {
+      const content = fs.readFileSync(p, "utf-8");
+      if (content.includes("path-terminal-sdk") || content.includes("PathTerminalSDK")) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function injectSPMDependency(packageSwiftPath) {
+  let content = fs.readFileSync(packageSwiftPath, "utf-8");
+  if (hasSDKDependency(packageSwiftPath)) return false;
+  const depsRegex = /(dependencies:\s*\[)/;
+  if (!depsRegex.test(content)) {
+    return false;
+  }
+  const depEntry = `
+        .package(url: "${SDK_GITHUB_URL}", from: "${SDK_VERSION}"),`;
+  content = content.replace(depsRegex, `$1${depEntry}`);
+  fs.writeFileSync(packageSwiftPath, content, "utf-8");
+  return true;
+}
+function writeCursorMcpConfig(dir) {
+  const cursorDir = path.join(dir, ".cursor");
+  const configPath = path.join(cursorDir, "mcp.json");
+  fs.mkdirSync(cursorDir, { recursive: true });
+  const pathEntry = {
+    "path-terminal": { url: MCP_SERVER_URL }
+  };
+  if (fs.existsSync(configPath)) {
+    try {
+      const existing = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+      if (!existing.mcpServers) existing.mcpServers = {};
+      if (existing.mcpServers["path-terminal"]) {
+        return { written: false, merged: false };
+      }
+      existing.mcpServers["path-terminal"] = pathEntry["path-terminal"];
+      fs.writeFileSync(configPath, JSON.stringify(existing, null, 2), "utf-8");
+      return { written: true, merged: true };
+    } catch {
+      return { written: false, merged: false };
+    }
+  }
+  const config = { mcpServers: pathEntry };
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+  return { written: true, merged: false };
+}
+function writeCursorRulesFile(dir, rulesSource = RULES_SOURCE, filename = "path-integration.mdc", fallbackUrl) {
+  const rulesDir = path.join(dir, ".cursor", "rules");
+  const destPath = path.join(rulesDir, filename);
+  fs.mkdirSync(rulesDir, { recursive: true });
+  if (fs.existsSync(destPath)) {
+    return { written: false, skipped: true };
+  }
+  const content = loadRulesContent(rulesSource, fallbackUrl);
+  if (!content) return { written: false, skipped: false };
+  fs.writeFileSync(destPath, content, "utf-8");
+  return { written: true, skipped: false };
+}
+function writeClaudeMcpConfig(dir) {
+  const configPath = path.join(dir, ".mcp.json");
+  const serverEntry = {
+    type: "sse",
+    url: MCP_SERVER_URL
+  };
+  if (fs.existsSync(configPath)) {
+    try {
+      const existing = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+      if (!existing.mcpServers) existing.mcpServers = {};
+      if (existing.mcpServers["path-terminal"]) {
+        return { written: false, merged: false };
+      }
+      existing.mcpServers["path-terminal"] = serverEntry;
+      fs.writeFileSync(configPath, JSON.stringify(existing, null, 2), "utf-8");
+      return { written: true, merged: true };
+    } catch {
+      return { written: false, merged: false };
+    }
+  }
+  const config = {
+    mcpServers: {
+      "path-terminal": serverEntry
+    }
+  };
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+  return { written: true, merged: false };
+}
+function writeClaudeSettings(dir) {
+  const claudeDir = path.join(dir, ".claude");
+  const settingsPath = path.join(claudeDir, "settings.json");
+  const MCP_NAME = "path-terminal";
+  if (!fs.existsSync(claudeDir)) {
+    fs.mkdirSync(claudeDir, { recursive: true });
+  }
+  if (fs.existsSync(settingsPath)) {
+    try {
+      const existing = JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
+      const current = Array.isArray(existing.enabledMcpjsonServers) ? existing.enabledMcpjsonServers : [];
+      if (current.includes(MCP_NAME)) {
+        return { written: false, merged: false, alreadyApproved: true };
+      }
+      existing.enabledMcpjsonServers = [...current, MCP_NAME];
+      fs.writeFileSync(settingsPath, JSON.stringify(existing, null, 2), "utf-8");
+      return { written: true, merged: true, alreadyApproved: false };
+    } catch {
+      return { written: false, merged: false, alreadyApproved: false };
+    }
+  }
+  const config = {
+    enabledMcpjsonServers: [MCP_NAME]
+  };
+  fs.writeFileSync(settingsPath, JSON.stringify(config, null, 2), "utf-8");
+  return { written: true, merged: false, alreadyApproved: false };
+}
+function writeClaudeRulesFile(dir, rulesSource = RULES_SOURCE, fallbackUrl) {
+  const destPath = path.join(dir, "CLAUDE.md");
+  if (fs.existsSync(destPath)) {
+    const content = fs.readFileSync(destPath, "utf-8");
+    if (content.includes("Path Terminal SDK")) {
+      return { written: false, skipped: true };
+    }
+    const rules2 = loadRulesContent(rulesSource, fallbackUrl);
+    if (!rules2) return { written: false, skipped: false };
+    fs.appendFileSync(destPath, "\n\n" + rules2, "utf-8");
+    return { written: true, skipped: false };
+  }
+  const rules = loadRulesContent(rulesSource, fallbackUrl);
+  if (!rules) return { written: false, skipped: false };
+  fs.writeFileSync(destPath, rules, "utf-8");
+  return { written: true, skipped: false };
+}
+function loadRulesContent(rulesSource = RULES_SOURCE, fallbackUrl) {
+  let raw = null;
+  if (fs.existsSync(rulesSource)) {
+    raw = fs.readFileSync(rulesSource, "utf-8");
+  } else if (fallbackUrl) {
+    try {
+      raw = (0, import_child_process.execSync)(`curl -sf --max-time 10 "${fallbackUrl}"`, { encoding: "utf-8" });
+    } catch {
+      return null;
+    }
+  }
+  if (!raw) return null;
+  const stripped = raw.replace(/^---[\s\S]*?---\s*/, "");
+  return stripped.trim();
+}
+function checkInfoPlist(dir) {
+  const issues = [];
+  const plistFiles = [];
+  function findPlists(d, depth = 0) {
+    if (depth > 4) return;
+    const entries = fs.readdirSync(d);
+    for (const e of entries) {
+      if (e === "node_modules" || e.startsWith(".")) continue;
+      const full = path.join(d, e);
+      const stat = fs.statSync(full);
+      if (stat.isDirectory()) findPlists(full, depth + 1);
+      else if (e === "Info.plist") plistFiles.push(full);
+    }
+  }
+  findPlists(dir);
+  for (const plist of plistFiles) {
+    const content = fs.readFileSync(plist, "utf-8");
+    if (!content.includes("NSBluetoothAlwaysUsageDescription")) {
+      issues.push(plist);
+    }
+  }
+  return issues;
+}
+function findAndroidProject(dir) {
+  return fs.existsSync(path.join(dir, "settings.gradle.kts")) && fs.existsSync(path.join(dir, "app", "build.gradle.kts"));
+}
+function hasAndroidSDKDependency(dir) {
+  const settingsPath = path.join(dir, "settings.gradle.kts");
+  if (!fs.existsSync(settingsPath)) return false;
+  const settings = fs.readFileSync(settingsPath, "utf-8");
+  if (!settings.includes("jitpack.io")) return false;
+  const buildPath = path.join(dir, "app", "build.gradle.kts");
+  if (!fs.existsSync(buildPath)) return true;
+  const build = fs.readFileSync(buildPath, "utf-8");
+  return /^\s*implementation\("com\.github\.keyman12\.path-terminal-sdk-android:path-terminal-sdk/m.test(build);
+}
+function injectJitPackRepo(dir) {
+  const settingsPath = path.join(dir, "settings.gradle.kts");
+  if (!fs.existsSync(settingsPath)) return false;
+  let content = fs.readFileSync(settingsPath, "utf-8");
+  if (content.includes("jitpack.io")) return true;
+  const repoRegex = /(dependencyResolutionManagement\s*\{[^}]*repositories\s*\{)/s;
+  if (!repoRegex.test(content)) return false;
+  content = content.replace(repoRegex, `$1
+        maven { url = uri("https://jitpack.io") }`);
+  fs.writeFileSync(settingsPath, content, "utf-8");
+  return true;
+}
+function injectGradleDependencies(dir) {
+  const buildPath = path.join(dir, "app", "build.gradle.kts");
+  if (!fs.existsSync(buildPath)) return false;
+  let content = fs.readFileSync(buildPath, "utf-8");
+  if (/^\s*implementation\("com\.github\.keyman12\.path-terminal-sdk-android:path-terminal-sdk/m.test(content)) return true;
+  if (content.includes("path-terminal-sdk-android")) {
+    content = content.replace(
+      /^\s*\/\/\s*implementation\("com\.github\.keyman12\.path-terminal-sdk-android:path-core-models[^"]*"\)/gm,
+      `    implementation("${ANDROID_SDK_JITPACK_GROUP}:path-core-models:${ANDROID_SDK_JITPACK_VERSION}")`
+    ).replace(
+      /^\s*\/\/\s*implementation\("com\.github\.keyman12\.path-terminal-sdk-android:path-terminal-sdk[^"]*"\)/gm,
+      `    implementation("${ANDROID_SDK_JITPACK_GROUP}:path-terminal-sdk:${ANDROID_SDK_JITPACK_VERSION}")`
+    ).replace(
+      /^\s*\/\/\s*implementation\("com\.github\.keyman12\.path-terminal-sdk-android:path-emulator-adapter[^"]*"\)/gm,
+      `    implementation("${ANDROID_SDK_JITPACK_GROUP}:path-emulator-adapter:${ANDROID_SDK_JITPACK_VERSION}")`
+    );
+    fs.writeFileSync(buildPath, content, "utf-8");
+    return true;
+  }
+  const deps = [
+    `    implementation("${ANDROID_SDK_JITPACK_GROUP}:path-core-models:${ANDROID_SDK_JITPACK_VERSION}")`,
+    `    implementation("${ANDROID_SDK_JITPACK_GROUP}:path-terminal-sdk:${ANDROID_SDK_JITPACK_VERSION}")`,
+    `    implementation("${ANDROID_SDK_JITPACK_GROUP}:path-emulator-adapter:${ANDROID_SDK_JITPACK_VERSION}")`
+  ].join("\n") + "\n";
+  const depsRegex = /(dependencies\s*\{)/;
+  if (!depsRegex.test(content)) return false;
+  content = content.replace(depsRegex, `$1
+${deps}`);
+  fs.writeFileSync(buildPath, content, "utf-8");
+  return true;
+}
+function checkAndroidManifest(dir) {
+  const issues = [];
+  function findManifests(d, depth = 0) {
+    if (depth > 4) return;
+    for (const e of fs.readdirSync(d)) {
+      if (e.startsWith(".") || e === "build") continue;
+      const full = path.join(d, e);
+      const stat = fs.statSync(full);
+      if (stat.isDirectory()) findManifests(full, depth + 1);
+      else if (e === "AndroidManifest.xml") {
+        const content = fs.readFileSync(full, "utf-8");
+        if (!content.includes("BLUETOOTH_SCAN")) issues.push(full);
+      }
+    }
+  }
+  findManifests(dir);
+  return issues;
+}
+function findCsprojFiles(dir) {
+  const found = [];
+  const walk = (d, depth) => {
+    if (depth > 1) return;
+    let entries = [];
+    try {
+      entries = fs.readdirSync(d);
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      if (e.startsWith(".") || e === "bin" || e === "obj") continue;
+      const full = path.join(d, e);
+      try {
+        const st = fs.statSync(full);
+        if (st.isDirectory()) walk(full, depth + 1);
+        else if (e.endsWith(".csproj")) found.push(full);
+      } catch {
+      }
+    }
+  };
+  walk(dir, 0);
+  return found;
+}
+function findWindowsProject(dir) {
+  let entries = [];
+  try {
+    entries = fs.readdirSync(dir);
+  } catch {
+    return false;
+  }
+  if (entries.some((e) => e.endsWith(".sln"))) return true;
+  return findCsprojFiles(dir).length > 0;
+}
+function detectWindowsFlavour(dir) {
+  const blob = findCsprojFiles(dir).map((f) => {
+    try {
+      return fs.readFileSync(f, "utf-8");
+    } catch {
+      return "";
+    }
+  }).join("\n").toLowerCase();
+  if (blob.includes("net48") || blob.includes("<usewpf>true") || blob.includes("v4.8")) return "windows10";
+  return "windows11";
+}
+function hasWindowsSDKDependency(dir) {
+  return findCsprojFiles(dir).some((f) => {
+    try {
+      return /Path\.Terminal\.Sdk/.test(fs.readFileSync(f, "utf-8"));
+    } catch {
+      return false;
+    }
+  });
+}
+function platformLabel(platform) {
+  switch (platform) {
+    case "android":
+      return "Android";
+    case "windows11":
+      return "Windows 11 (WinUI 3 / .NET 10)";
+    case "windows10":
+      return "Windows 10 (WPF / .NET FW 4.8)";
+    default:
+      return "iOS";
+  }
+}
+function printSummary(agent, platform, actions, warnings, manualSteps) {
+  const isAndroid = platform === "android";
+  const isWindows = platform === "windows11" || platform === "windows10";
+  console.log("\n" + import_chalk.default.bold("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  console.log(import_chalk.default.bold(`  Path Terminal SDK \u2014 Setup Complete (${platformLabel(platform)})`));
+  console.log(import_chalk.default.bold("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n"));
+  if (actions.length > 0) {
+    console.log(import_chalk.default.green("\u2713 Done:"));
+    actions.forEach((a) => console.log(import_chalk.default.green(`  \u2022 ${a}`)));
+    console.log();
+  }
+  if (manualSteps.length > 0) {
+    console.log(import_chalk.default.yellow("\u26A0 Manual steps required:"));
+    manualSteps.forEach((s, i) => console.log(import_chalk.default.yellow(`  ${i + 1}. ${s}`)));
+    console.log();
+  }
+  if (warnings.length > 0) {
+    console.log(import_chalk.default.dim("\u2139 Notes:"));
+    warnings.forEach((w) => console.log(import_chalk.default.dim(`  \u2022 ${w}`)));
+    console.log();
+  }
+  const mcpPrompt = platform === "android" ? "integrate-path-android" : platform === "windows11" ? "integrate-path-windows11" : platform === "windows10" ? "integrate-path-windows10" : "integrate-path-sale";
+  const firstPrompt = '  "Integrate the Path Terminal SDK into this EPOS app. Read CLAUDE.md\n   for the integration rules, then use the Path MCP ' + mcpPrompt + '\n   prompt to add a Path POS Adapter in Settings \u2014 a backend switcher for the\n   Path POS Emulator (Wi-Fi/IP or Bluetooth) and a real Verifone terminal."';
+  if (agent === "claude") {
+    console.log(import_chalk.default.bold("\u{1F680} Start Claude Code in this directory:"));
+    console.log(import_chalk.default.cyan("  claude --model sonnet"));
+    console.log();
+    console.log(import_chalk.default.bold("  Then paste this prompt:"));
+    console.log(import_chalk.default.cyan(firstPrompt));
+  } else {
+    console.log(import_chalk.default.bold("\u{1F680} Your first prompt in Cursor:"));
+    console.log(import_chalk.default.cyan(firstPrompt));
+  }
+  console.log();
+  console.log(import_chalk.default.dim(`  MCP server: ${MCP_SERVER_URL}`));
+  console.log(import_chalk.default.dim("  Docs:       https://mcp.path2ai.tech/health"));
+  console.log();
+}
+import_commander.program.name("path-terminal-init").description(
+  "Set up the Path Terminal SDK integration assistant for your EPOS project.\nAuto-detects platform (iOS, Android, or Windows) from the current directory.\nConfigures MCP server access, drops the integration recipe, and optionally\nadds the SDK dependency.\n\nSupported agents: claude (default), cursor\nSupported platforms: ios (default), android, windows11 (WinUI 3 / .NET 10),\nwindows10 (WPF / .NET FW 4.8). Use 'windows' to auto-pick the Windows flavour."
+).version("0.2.0").option("--tools-only", "Only configure MCP + rules. Skip SDK installation.").option("--agent <name>", "AI agent to configure: 'claude' (default) or 'cursor'.", "claude").option("--platform <name>", "Platform: ios | android | windows | windows11 | windows10. Auto-detected if not specified.").action(async (options) => {
+  const toolsOnly = options.toolsOnly ?? false;
+  const agent = options.agent ?? "claude";
+  const cwd = process.cwd();
+  const rawPlatform = options.platform ?? "auto";
+  const VALID_PLATFORMS = ["ios", "android", "windows", "windows11", "windows10"];
+  let platform;
+  if (rawPlatform === "auto" || !VALID_PLATFORMS.includes(rawPlatform)) {
+    if (findAndroidProject(cwd)) platform = "android";
+    else if (findWindowsProject(cwd)) platform = detectWindowsFlavour(cwd);
+    else platform = "ios";
+  } else if (rawPlatform === "windows") {
+    platform = detectWindowsFlavour(cwd);
+  } else {
+    platform = rawPlatform;
+  }
+  const isAndroid = platform === "android";
+  const isWindows = platform === "windows11" || platform === "windows10";
+  console.log();
+  console.log(import_chalk.default.bold("  Path Terminal SDK \u2014 Integration Assistant Setup"));
+  console.log(import_chalk.default.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  console.log(import_chalk.default.dim(`  Agent:    ${agent}`));
+  console.log(import_chalk.default.dim(`  Platform: ${platform}${options.platform ? "" : " (auto-detected)"}`));
+  console.log();
+  if (agent !== "cursor" && agent !== "claude") {
+    console.log(
+      import_chalk.default.yellow(
+        `\u26A0 Agent '${agent}' is not supported. Use 'cursor' or 'claude'.`
+      )
+    );
+    process.exit(1);
+  }
+  const actions = [];
+  const warnings = [];
+  const manualSteps = [];
+  if (!toolsOnly) {
+    if (isAndroid) {
+      const spinner = (0, import_ora.default)("Checking Android project\u2026").start();
+      if (!findAndroidProject(cwd)) {
+        spinner.warn("No Android project found (settings.gradle.kts or app/build.gradle.kts missing).");
+        const answer = await ask(
+          import_chalk.default.yellow("  Continue with tools-only setup? (y/n): ")
+        );
+        if (answer.toLowerCase() !== "y") {
+          console.log(import_chalk.default.dim("\n  Run this from your Android project root directory.\n"));
+          process.exit(0);
+        }
+        warnings.push("Ran in tools-only mode \u2014 no Android project found.");
+      } else if (hasAndroidSDKDependency(cwd)) {
+        spinner.succeed("Path Terminal SDK already present in settings.gradle.kts.");
+        actions.push("SDK dependency already present \u2014 no change needed.");
+      } else {
+        spinner.text = "Adding JitPack repository to settings.gradle.kts\u2026";
+        const settingsOk = injectJitPackRepo(cwd);
+        const depsOk = injectGradleDependencies(cwd);
+        if (settingsOk) {
+          spinner.succeed("JitPack repository added to settings.gradle.kts.");
+          actions.push("JitPack repository added to settings.gradle.kts");
+        }
+        if (depsOk) {
+          spinner.succeed("SDK dependencies added to app/build.gradle.kts.");
+          actions.push("path-terminal-sdk + path-emulator-adapter added to app/build.gradle.kts");
+        } else {
+          spinner.warn("Could not auto-inject dependencies into app/build.gradle.kts.");
+          manualSteps.push(
+            `Add to app/build.gradle.kts dependencies {}:
+     implementation("${ANDROID_SDK_JITPACK_GROUP}:path-terminal-sdk:${ANDROID_SDK_JITPACK_VERSION}")
+     implementation("${ANDROID_SDK_JITPACK_GROUP}:path-emulator-adapter:${ANDROID_SDK_JITPACK_VERSION}")`
+          );
+        }
+      }
+    } else if (isWindows) {
+      const spinner = (0, import_ora.default)("Checking Windows (.NET) project\u2026").start();
+      if (!findWindowsProject(cwd)) {
+        spinner.warn("No Windows project found (.sln or .csproj).");
+        const answer = await ask(import_chalk.default.yellow("  Continue with tools-only setup? (y/n): "));
+        if (answer.toLowerCase() !== "y") {
+          console.log(import_chalk.default.dim("\n  Run this from your Windows EPOS project root.\n"));
+          process.exit(0);
+        }
+        warnings.push("Ran in tools-only mode \u2014 no Windows project found.");
+      } else if (hasWindowsSDKDependency(cwd)) {
+        spinner.succeed("Path Terminal SDK already referenced in the project.");
+        actions.push("SDK ProjectReference already present \u2014 no change needed.");
+      } else {
+        spinner.info("Path SDK is wired by ProjectReference \u2014 the integration recipe (Step 0) does this.");
+        manualSteps.push(
+          `Add the Path SDK ProjectReferences to your .csproj \u2014 the integration recipe's Step 0 lists all six (CoreModels, Sdk, EmulatorAdapter, MockAdapter, Diagnostics, PsdkAdapter). Clone ${WINDOWS_SDK_REPO} as a SIBLING folder of this project first.`
+        );
+      }
+    } else {
+      const spinner = (0, import_ora.default)("Checking for Xcode project\u2026").start();
+      const xcodeProject = findXcodeProject(cwd);
+      const packageSwift = findPackageSwift(cwd);
+      if (packageSwift) {
+        spinner.text = "Found Package.swift \u2014 adding PathTerminalSDK dependency\u2026";
+        if (hasSDKDependency(packageSwift)) {
+          spinner.succeed("PathTerminalSDK already present in Package.swift.");
+          actions.push("PathTerminalSDK dependency already present \u2014 no change needed.");
+        } else {
+          const injected = injectSPMDependency(packageSwift);
+          if (injected) {
+            spinner.succeed("PathTerminalSDK added to Package.swift.");
+            actions.push("PathTerminalSDK added to Package.swift");
+            manualSteps.push(
+              `Open Xcode and link all three targets to your app: PathTerminalSDK, PathEmulatorAdapter, PathCoreModels.`
+            );
+          } else {
+            spinner.warn("Could not automatically modify Package.swift \u2014 manual step required.");
+            manualSteps.push(
+              `Add PathTerminalSDK manually to Package.swift:
+     .package(url: "${SDK_GITHUB_URL}", from: "${SDK_VERSION}")`
+            );
+          }
+        }
+      } else if (xcodeProject) {
+        spinner.succeed(`Found Xcode project: ${path.basename(xcodeProject)}`);
+        if (hasXcodeProjectSDKDependency(xcodeProject)) {
+          spinner.succeed("PathTerminalSDK already present in Xcode project.");
+          actions.push("PathTerminalSDK dependency already present \u2014 no change needed.");
+        } else {
+          console.log(
+            import_chalk.default.yellow(
+              "\n  \u26A0 Automatic SPM injection into .xcodeproj is not supported (Xcode manages this)."
+            )
+          );
+          console.log(import_chalk.default.bold("\n  To add PathTerminalSDK in Xcode:"));
+          console.log("  1. Open your project in Xcode");
+          console.log("  2. File \u2192 Add Package Dependencies\u2026");
+          console.log(`  3. Enter URL: ${import_chalk.default.cyan(SDK_GITHUB_URL)}`);
+          console.log(
+            "  4. In the 'Choose Package Products' dialog, set all three to your app target:"
+          );
+          console.log(import_chalk.default.cyan("       PathTerminalSDK    \u2192 your app target"));
+          console.log(import_chalk.default.cyan("       PathEmulatorAdapter \u2192 your app target"));
+          console.log(import_chalk.default.cyan("       PathCoreModels      \u2192 your app target"));
+          console.log(import_chalk.default.dim("     (PathDiagnostics can be left as None)"));
+          console.log("  5. Click Add Package\n");
+          const confirmed = await ask(
+            import_chalk.default.bold("  Press Enter once you have added the package, or type 'skip' to do this later: ")
+          );
+          if (confirmed.toLowerCase() !== "skip") {
+            actions.push(`PathTerminalSDK added to Xcode project (confirmed by user)`);
+          } else {
+            manualSteps.push(
+              `Add PathTerminalSDK via Xcode: File \u2192 Add Package Dependencies \u2192 ${SDK_GITHUB_URL}`
+            );
+          }
+        }
+      } else {
+        spinner.warn("No Xcode project found in current directory.");
+        const answer = await ask(
+          import_chalk.default.yellow(
+            "  No .xcodeproj or Package.swift found. Continue with tools-only setup? (y/n): "
+          )
+        );
+        if (answer.toLowerCase() !== "y") {
+          console.log(
+            import_chalk.default.dim("\n  Run this command from your Xcode project directory, or use --tools-only.\n")
+          );
+          process.exit(0);
+        }
+        warnings.push("Ran in tools-only mode \u2014 no Xcode project found.");
+      }
+    }
+  } else {
+    actions.push("Skipped SDK installation (--tools-only mode)");
+  }
+  {
+    const spinner = (0, import_ora.default)("Writing MCP server config\u2026").start();
+    let result;
+    let configFile;
+    if (agent === "claude") {
+      result = writeClaudeMcpConfig(cwd);
+      configFile = ".mcp.json";
+    } else {
+      result = writeCursorMcpConfig(cwd);
+      configFile = ".cursor/mcp.json";
+    }
+    if (result.written && result.merged) {
+      spinner.succeed(`MCP config merged into existing ${configFile}.`);
+      actions.push(`path-terminal entry merged into ${configFile}`);
+    } else if (result.written) {
+      spinner.succeed(`MCP config written to ${configFile}.`);
+      actions.push(`MCP server configured: ${configFile}`);
+    } else {
+      spinner.info("MCP config already present \u2014 no change needed.");
+      actions.push("MCP config already present \u2014 no change needed.");
+    }
+    if (agent === "claude") {
+      const approveSpinner = (0, import_ora.default)("Pre-approving Path MCP server for Claude Code\u2026").start();
+      const approve = writeClaudeSettings(cwd);
+      if (approve.alreadyApproved) {
+        approveSpinner.info("Path MCP server already pre-approved \u2014 no change needed.");
+      } else if (approve.written && approve.merged) {
+        approveSpinner.succeed("path-terminal added to existing .claude/settings.json.");
+        actions.push("path-terminal pre-approved in .claude/settings.json");
+      } else if (approve.written) {
+        approveSpinner.succeed("Pre-approval written to .claude/settings.json.");
+        actions.push("Claude Code pre-approval: .claude/settings.json");
+      } else {
+        approveSpinner.warn('Could not write .claude/settings.json \u2014 you may see an "Allow MCP server?" prompt on first Claude Code launch. Accept it.');
+      }
+    }
+  }
+  {
+    const spinner = (0, import_ora.default)(`Writing ${agent === "claude" ? "CLAUDE.md" : "Cursor rules"} file\u2026`).start();
+    let result;
+    let rulesFile;
+    const rulesByPlatform = {
+      ios: { src: RULES_SOURCE, url: RULES_FETCH_URL, file: "path-integration.mdc" },
+      android: { src: ANDROID_RULES_SOURCE, url: ANDROID_RULES_FETCH_URL, file: "path-integration-android.mdc" },
+      windows11: { src: WINDOWS11_RULES_SOURCE, url: WINDOWS11_RULES_FETCH_URL, file: "path-integration-windows11.mdc" },
+      windows10: { src: WINDOWS10_RULES_SOURCE, url: WINDOWS10_RULES_FETCH_URL, file: "path-integration-windows10.mdc" }
+    };
+    const activeRules = rulesByPlatform[platform];
+    const activeFetchUrl = activeRules.url;
+    if (agent === "claude") {
+      result = writeClaudeRulesFile(cwd, activeRules.src, activeFetchUrl);
+      rulesFile = "CLAUDE.md";
+    } else {
+      result = writeCursorRulesFile(cwd, activeRules.src, activeRules.file, activeFetchUrl);
+      rulesFile = `.cursor/rules/${activeRules.file}`;
+    }
+    if (result.written) {
+      spinner.succeed(`Rules file written to ${rulesFile}.`);
+      actions.push(`Integration rules file: ${rulesFile}`);
+    } else if (result.skipped) {
+      spinner.info(
+        `${rulesFile} already exists \u2014 skipped to preserve your customisations.`
+      );
+      warnings.push(
+        `${rulesFile} already exists \u2014 not overwritten.`
+      );
+    } else {
+      spinner.warn("Could not write rules file \u2014 check network connectivity.");
+      manualSteps.push(
+        `Download ${activeRules.file} manually from: ${activeFetchUrl}`
+      );
+    }
+  }
+  if (!toolsOnly) {
+    if (isAndroid) {
+      const spinner = (0, import_ora.default)("Checking AndroidManifest.xml BLE permissions\u2026").start();
+      const manifestsWithIssues = checkAndroidManifest(cwd);
+      if (manifestsWithIssues.length === 0) {
+        spinner.succeed("BLE permissions found in AndroidManifest.xml.");
+        actions.push("BLE permissions verified in AndroidManifest.xml");
+      } else {
+        spinner.warn(
+          `BLUETOOTH_SCAN missing from ${manifestsWithIssues.length} AndroidManifest.xml file(s).`
+        );
+        manifestsWithIssues.forEach((p) => {
+          const relative = path.relative(cwd, p);
+          manualSteps.push(
+            `Add BLE permissions to ${relative}:
+     (Ask the MCP: "get_manifest_requirements" for the full XML)`
+          );
+        });
+      }
+    } else if (isWindows) {
+      actions.push("Bluetooth needs no manifest entry on Windows (WinRT).");
+    } else {
+      const spinner = (0, import_ora.default)("Checking Info.plist BLE permissions\u2026").start();
+      const plistsWithIssues = checkInfoPlist(cwd);
+      if (plistsWithIssues.length === 0) {
+        spinner.succeed("BLE permissions found in Info.plist.");
+        actions.push("BLE permissions verified in Info.plist");
+      } else {
+        spinner.warn(
+          `NSBluetoothAlwaysUsageDescription missing from ${plistsWithIssues.length} Info.plist file(s).`
+        );
+        plistsWithIssues.forEach((p) => {
+          const relative = path.relative(cwd, p);
+          manualSteps.push(
+            `Add BLE permission to ${relative}:
+     <key>NSBluetoothAlwaysUsageDescription</key>
+     <string>This app connects to a Path payment terminal via Bluetooth.</string>
+     (Ask the MCP: "get_info_plist_requirements" for the full XML)`
+          );
+        });
+      }
+    }
+  }
+  printSummary(agent, platform, actions, warnings, manualSteps);
+});
+import_commander.program.parse(process.argv);
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/cli.ts"],
  "sourcesContent": ["#!/usr/bin/env node\n\nimport { program } from \"commander\";\nimport chalk from \"chalk\";\nimport * as fs from \"fs\";\nimport * as path from \"path\";\nimport * as readline from \"readline\";\nimport { execSync } from \"child_process\";\nimport ora from \"ora\";\n\nconst SDK_GITHUB_URL = \"https://github.com/keyman12/path-terminal-sdk\";\nconst ANDROID_SDK_GITHUB_URL = \"https://github.com/keyman12/path-terminal-sdk-android\";\nconst SDK_VERSION = \"0.1.0\"; // minimum version to reference\nconst ANDROID_SDK_JITPACK_VERSION = \"v1.4\";\nconst ANDROID_SDK_JITPACK_GROUP = \"com.github.keyman12.path-terminal-sdk-android\";\nconst MCP_SERVER_URL = \"https://mcp.path2ai.tech/sse\";\nconst RULES_FETCH_URL = \"https://mcp.path2ai.tech/rules\";\nconst ANDROID_RULES_FETCH_URL = \"https://mcp.path2ai.tech/rules/android\";\nconst WINDOWS11_RULES_FETCH_URL = \"https://mcp.path2ai.tech/rules/windows11\";\nconst WINDOWS10_RULES_FETCH_URL = \"https://mcp.path2ai.tech/rules/windows10\";\n\nconst RULES_SOURCE = path.join(__dirname, \"../rules/ios/path-integration.mdc\");\nconst ANDROID_RULES_SOURCE = path.join(__dirname, \"../rules/android/path-integration-android.mdc\");\nconst WINDOWS11_RULES_SOURCE = path.join(__dirname, \"../rules/windows-11/path-integration-windows11.mdc\");\nconst WINDOWS10_RULES_SOURCE = path.join(__dirname, \"../rules/windows-10/path-integration-windows10.mdc\");\n\n// The Windows SDK is consumed by relative ProjectReference to this sibling clone\n// (one repo serves both the WinUI 3 / .NET 10 and WPF / .NET FW 4.8 stacks).\nconst WINDOWS_SDK_REPO = \"Path-terminal-sdk-windows11\";\n\ntype AgentType = \"cursor\" | \"claude\";\ntype Platform = \"ios\" | \"android\" | \"windows11\" | \"windows10\";\n\n// \u2500\u2500\u2500 Utilities \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\nfunction ask(question: string): Promise<string> {\n  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });\n  return new Promise((resolve) => {\n    rl.question(question, (answer) => {\n      rl.close();\n      resolve(answer.trim());\n    });\n  });\n}\n\nfunction findXcodeProject(dir: string): string | null {\n  const isXcodeArtifact = (e: string) =>\n    e.endsWith(\".xcodeproj\") || e.endsWith(\".xcworkspace\");\n\n  // Check the current directory first\n  const entries = fs.readdirSync(dir);\n  const proj = entries.find(isXcodeArtifact);\n  if (proj) return path.join(dir, proj);\n\n  // Search one level deep in subdirectories (handles repos where the\n  // Xcode project sits inside a named subfolder, e.g. OrderchampionEPOS/)\n  for (const entry of entries) {\n    if (entry.startsWith(\".\")) continue;\n    const sub = path.join(dir, entry);\n    try {\n      if (fs.statSync(sub).isDirectory()) {\n        const subEntries = fs.readdirSync(sub);\n        const subProj = subEntries.find(isXcodeArtifact);\n        if (subProj) return path.join(sub, subProj);\n      }\n    } catch { /* skip unreadable dirs */ }\n  }\n\n  return null;\n}\n\nfunction findPackageSwift(dir: string): string | null {\n  const p = path.join(dir, \"Package.swift\");\n  return fs.existsSync(p) ? p : null;\n}\n\nfunction hasSDKDependency(packageSwift: string): boolean {\n  const content = fs.readFileSync(packageSwift, \"utf-8\");\n  return content.includes(\"path-terminal-sdk\") || content.includes(\"PathTerminalSDK\");\n}\n\nfunction hasXcodeProjectSDKDependency(xcodeProject: string): boolean {\n  // Xcode stores resolved SPM packages in the workspace's Package.resolved\n  const resolvedPaths = [\n    path.join(xcodeProject, \"project.xcworkspace\", \"xcshareddata\", \"swiftpm\", \"Package.resolved\"),\n    path.join(xcodeProject, \"xcshareddata\", \"swiftpm\", \"Package.resolved\"),\n  ];\n  for (const p of resolvedPaths) {\n    if (fs.existsSync(p)) {\n      const content = fs.readFileSync(p, \"utf-8\");\n      if (content.includes(\"path-terminal-sdk\") || content.includes(\"PathTerminalSDK\")) {\n        return true;\n      }\n    }\n  }\n  return false;\n}\n\nfunction injectSPMDependency(packageSwiftPath: string): boolean {\n  let content = fs.readFileSync(packageSwiftPath, \"utf-8\");\n\n  // Already present?\n  if (hasSDKDependency(packageSwiftPath)) return false;\n\n  // Add the package dependency \u2014 find the dependencies: [ array\n  const depsRegex = /(dependencies:\\s*\\[)/;\n  if (!depsRegex.test(content)) {\n    return false; // Can't safely inject \u2014 structure not recognised\n  }\n\n  const depEntry = `\\n        .package(url: \"${SDK_GITHUB_URL}\", from: \"${SDK_VERSION}\"),`;\n  content = content.replace(depsRegex, `$1${depEntry}`);\n  fs.writeFileSync(packageSwiftPath, content, \"utf-8\");\n  return true;\n}\n\n// \u2500\u2500\u2500 Cursor-specific config \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\nfunction writeCursorMcpConfig(dir: string): { written: boolean; merged: boolean } {\n  const cursorDir = path.join(dir, \".cursor\");\n  const configPath = path.join(cursorDir, \"mcp.json\");\n\n  fs.mkdirSync(cursorDir, { recursive: true });\n\n  const pathEntry = {\n    \"path-terminal\": { url: MCP_SERVER_URL },\n  };\n\n  if (fs.existsSync(configPath)) {\n    try {\n      const existing = JSON.parse(fs.readFileSync(configPath, \"utf-8\"));\n      if (!existing.mcpServers) existing.mcpServers = {};\n      if (existing.mcpServers[\"path-terminal\"]) {\n        return { written: false, merged: false }; // already present\n      }\n      existing.mcpServers[\"path-terminal\"] = pathEntry[\"path-terminal\"];\n      fs.writeFileSync(configPath, JSON.stringify(existing, null, 2), \"utf-8\");\n      return { written: true, merged: true };\n    } catch {\n      // File exists but is not valid JSON \u2014 don't overwrite\n      return { written: false, merged: false };\n    }\n  }\n\n  const config = { mcpServers: pathEntry };\n  fs.writeFileSync(configPath, JSON.stringify(config, null, 2), \"utf-8\");\n  return { written: true, merged: false };\n}\n\nfunction writeCursorRulesFile(dir: string, rulesSource: string = RULES_SOURCE, filename: string = \"path-integration.mdc\", fallbackUrl?: string): { written: boolean; skipped: boolean } {\n  const rulesDir = path.join(dir, \".cursor\", \"rules\");\n  const destPath = path.join(rulesDir, filename);\n\n  fs.mkdirSync(rulesDir, { recursive: true });\n\n  if (fs.existsSync(destPath)) {\n    return { written: false, skipped: true };\n  }\n\n  const content = loadRulesContent(rulesSource, fallbackUrl);\n  if (!content) return { written: false, skipped: false };\n\n  fs.writeFileSync(destPath, content, \"utf-8\");\n  return { written: true, skipped: false };\n}\n\n// \u2500\u2500\u2500 Claude Code-specific config \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\nfunction writeClaudeMcpConfig(dir: string): { written: boolean; merged: boolean } {\n  // Claude Code reads .mcp.json at the project root (same mcpServers format as Cursor)\n  const configPath = path.join(dir, \".mcp.json\");\n\n  const serverEntry = {\n    type: \"sse\",\n    url: MCP_SERVER_URL,\n  };\n\n  if (fs.existsSync(configPath)) {\n    try {\n      const existing = JSON.parse(fs.readFileSync(configPath, \"utf-8\"));\n      if (!existing.mcpServers) existing.mcpServers = {};\n      if (existing.mcpServers[\"path-terminal\"]) {\n        return { written: false, merged: false }; // already present\n      }\n      existing.mcpServers[\"path-terminal\"] = serverEntry;\n      fs.writeFileSync(configPath, JSON.stringify(existing, null, 2), \"utf-8\");\n      return { written: true, merged: true };\n    } catch {\n      return { written: false, merged: false };\n    }\n  }\n\n  const config = {\n    mcpServers: {\n      \"path-terminal\": serverEntry,\n    },\n  };\n  fs.writeFileSync(configPath, JSON.stringify(config, null, 2), \"utf-8\");\n  return { written: true, merged: false };\n}\n\n// Pre-approve the path-terminal MCP server in .claude/settings.json so Claude\n// Code loads its tools on the very first session without the user having to\n// click through an approval prompt (which is easy to miss and leaves the agent\n// running without MCP tools).\nfunction writeClaudeSettings(dir: string): { written: boolean; merged: boolean; alreadyApproved: boolean } {\n  const claudeDir = path.join(dir, \".claude\");\n  const settingsPath = path.join(claudeDir, \"settings.json\");\n  const MCP_NAME = \"path-terminal\";\n\n  if (!fs.existsSync(claudeDir)) {\n    fs.mkdirSync(claudeDir, { recursive: true });\n  }\n\n  if (fs.existsSync(settingsPath)) {\n    try {\n      const existing = JSON.parse(fs.readFileSync(settingsPath, \"utf-8\"));\n      const current: string[] = Array.isArray(existing.enabledMcpjsonServers) ? existing.enabledMcpjsonServers : [];\n      if (current.includes(MCP_NAME)) {\n        return { written: false, merged: false, alreadyApproved: true };\n      }\n      existing.enabledMcpjsonServers = [...current, MCP_NAME];\n      fs.writeFileSync(settingsPath, JSON.stringify(existing, null, 2), \"utf-8\");\n      return { written: true, merged: true, alreadyApproved: false };\n    } catch {\n      return { written: false, merged: false, alreadyApproved: false };\n    }\n  }\n\n  const config = {\n    enabledMcpjsonServers: [MCP_NAME],\n  };\n  fs.writeFileSync(settingsPath, JSON.stringify(config, null, 2), \"utf-8\");\n  return { written: true, merged: false, alreadyApproved: false };\n}\n\nfunction writeClaudeRulesFile(dir: string, rulesSource: string = RULES_SOURCE, fallbackUrl?: string): { written: boolean; skipped: boolean } {\n  const destPath = path.join(dir, \"CLAUDE.md\");\n\n  // Don't overwrite an existing CLAUDE.md \u2014 it may have custom instructions\n  if (fs.existsSync(destPath)) {\n    const content = fs.readFileSync(destPath, \"utf-8\");\n    if (content.includes(\"Path Terminal SDK\")) {\n      return { written: false, skipped: true };\n    }\n    // Append to existing CLAUDE.md\n    const rules = loadRulesContent(rulesSource, fallbackUrl);\n    if (!rules) return { written: false, skipped: false };\n    fs.appendFileSync(destPath, \"\\n\\n\" + rules, \"utf-8\");\n    return { written: true, skipped: false };\n  }\n\n  const rules = loadRulesContent(rulesSource, fallbackUrl);\n  if (!rules) return { written: false, skipped: false };\n  fs.writeFileSync(destPath, rules, \"utf-8\");\n  return { written: true, skipped: false };\n}\n\nfunction loadRulesContent(rulesSource: string = RULES_SOURCE, fallbackUrl?: string): string | null {\n  let raw: string | null = null;\n\n  if (fs.existsSync(rulesSource)) {\n    raw = fs.readFileSync(rulesSource, \"utf-8\");\n  } else if (fallbackUrl) {\n    try {\n      raw = execSync(`curl -sf --max-time 10 \"${fallbackUrl}\"`, { encoding: \"utf-8\" });\n    } catch {\n      return null;\n    }\n  }\n\n  if (!raw) return null;\n\n  // Strip the YAML frontmatter (--- ... ---) that Cursor uses\n  const stripped = raw.replace(/^---[\\s\\S]*?---\\s*/, \"\");\n  return stripped.trim();\n}\n\n// \u2500\u2500\u2500 Shared \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\nfunction checkInfoPlist(dir: string): string[] {\n  const issues: string[] = [];\n  const plistFiles: string[] = [];\n\n  function findPlists(d: string, depth: number = 0) {\n    if (depth > 4) return;\n    const entries = fs.readdirSync(d);\n    for (const e of entries) {\n      if (e === \"node_modules\" || e.startsWith(\".\")) continue;\n      const full = path.join(d, e);\n      const stat = fs.statSync(full);\n      if (stat.isDirectory()) findPlists(full, depth + 1);\n      else if (e === \"Info.plist\") plistFiles.push(full);\n    }\n  }\n\n  findPlists(dir);\n\n  for (const plist of plistFiles) {\n    const content = fs.readFileSync(plist, \"utf-8\");\n    if (!content.includes(\"NSBluetoothAlwaysUsageDescription\")) {\n      issues.push(plist);\n    }\n  }\n\n  return issues;\n}\n\n// \u2500\u2500\u2500 Android helpers \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\nfunction findAndroidProject(dir: string): boolean {\n  return fs.existsSync(path.join(dir, \"settings.gradle.kts\")) &&\n         fs.existsSync(path.join(dir, \"app\", \"build.gradle.kts\"));\n}\n\nfunction hasAndroidSDKDependency(dir: string): boolean {\n  // Check settings.gradle.kts has JitPack repo\n  const settingsPath = path.join(dir, \"settings.gradle.kts\");\n  if (!fs.existsSync(settingsPath)) return false;\n  const settings = fs.readFileSync(settingsPath, \"utf-8\");\n  if (!settings.includes(\"jitpack.io\")) return false;\n  // Check build.gradle.kts has the dependency uncommented\n  const buildPath = path.join(dir, \"app\", \"build.gradle.kts\");\n  if (!fs.existsSync(buildPath)) return true;\n  const build = fs.readFileSync(buildPath, \"utf-8\");\n  return /^\\s*implementation\\(\"com\\.github\\.keyman12\\.path-terminal-sdk-android:path-terminal-sdk/m.test(build);\n}\n\nfunction injectJitPackRepo(dir: string): boolean {\n  const settingsPath = path.join(dir, \"settings.gradle.kts\");\n  if (!fs.existsSync(settingsPath)) return false;\n  let content = fs.readFileSync(settingsPath, \"utf-8\");\n  if (content.includes(\"jitpack.io\")) return true; // already present\n  // Add jitpack inside dependencyResolutionManagement repositories block\n  const repoRegex = /(dependencyResolutionManagement\\s*\\{[^}]*repositories\\s*\\{)/s;\n  if (!repoRegex.test(content)) return false;\n  content = content.replace(repoRegex, `$1\\n        maven { url = uri(\"https://jitpack.io\") }`);\n  fs.writeFileSync(settingsPath, content, \"utf-8\");\n  return true;\n}\n\nfunction injectGradleDependencies(dir: string): boolean {\n  const buildPath = path.join(dir, \"app\", \"build.gradle.kts\");\n  if (!fs.existsSync(buildPath)) return false;\n  let content = fs.readFileSync(buildPath, \"utf-8\");\n\n  // Already present and uncommented \u2014 nothing to do\n  if (/^\\s*implementation\\(\"com\\.github\\.keyman12\\.path-terminal-sdk-android:path-terminal-sdk/m.test(content)) return true;\n\n  // Present but commented out \u2014 uncomment those lines\n  if (content.includes(\"path-terminal-sdk-android\")) {\n    content = content\n      .replace(/^\\s*\\/\\/\\s*implementation\\(\"com\\.github\\.keyman12\\.path-terminal-sdk-android:path-core-models[^\"]*\"\\)/gm,\n        `    implementation(\"${ANDROID_SDK_JITPACK_GROUP}:path-core-models:${ANDROID_SDK_JITPACK_VERSION}\")`)\n      .replace(/^\\s*\\/\\/\\s*implementation\\(\"com\\.github\\.keyman12\\.path-terminal-sdk-android:path-terminal-sdk[^\"]*\"\\)/gm,\n        `    implementation(\"${ANDROID_SDK_JITPACK_GROUP}:path-terminal-sdk:${ANDROID_SDK_JITPACK_VERSION}\")`)\n      .replace(/^\\s*\\/\\/\\s*implementation\\(\"com\\.github\\.keyman12\\.path-terminal-sdk-android:path-emulator-adapter[^\"]*\"\\)/gm,\n        `    implementation(\"${ANDROID_SDK_JITPACK_GROUP}:path-emulator-adapter:${ANDROID_SDK_JITPACK_VERSION}\")`);\n    fs.writeFileSync(buildPath, content, \"utf-8\");\n    return true;\n  }\n\n  // Not present at all \u2014 inject after opening brace\n  const deps = [\n    `    implementation(\"${ANDROID_SDK_JITPACK_GROUP}:path-core-models:${ANDROID_SDK_JITPACK_VERSION}\")`,\n    `    implementation(\"${ANDROID_SDK_JITPACK_GROUP}:path-terminal-sdk:${ANDROID_SDK_JITPACK_VERSION}\")`,\n    `    implementation(\"${ANDROID_SDK_JITPACK_GROUP}:path-emulator-adapter:${ANDROID_SDK_JITPACK_VERSION}\")`,\n  ].join(\"\\n\") + \"\\n\";\n  const depsRegex = /(dependencies\\s*\\{)/;\n  if (!depsRegex.test(content)) return false;\n  content = content.replace(depsRegex, `$1\\n${deps}`);\n  fs.writeFileSync(buildPath, content, \"utf-8\");\n  return true;\n}\n\nfunction checkAndroidManifest(dir: string): string[] {\n  const issues: string[] = [];\n  function findManifests(d: string, depth: number = 0) {\n    if (depth > 4) return;\n    for (const e of fs.readdirSync(d)) {\n      if (e.startsWith(\".\") || e === \"build\") continue;\n      const full = path.join(d, e);\n      const stat = fs.statSync(full);\n      if (stat.isDirectory()) findManifests(full, depth + 1);\n      else if (e === \"AndroidManifest.xml\") {\n        const content = fs.readFileSync(full, \"utf-8\");\n        if (!content.includes(\"BLUETOOTH_SCAN\")) issues.push(full);\n      }\n    }\n  }\n  findManifests(dir);\n  return issues;\n}\n\n// \u2500\u2500\u2500 Windows helpers (.NET \u2014 WinUI 3 / .NET 10 and WPF / .NET FW 4.8) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n// Collect .csproj file paths in cwd and one level deep.\nfunction findCsprojFiles(dir: string): string[] {\n  const found: string[] = [];\n  const walk = (d: string, depth: number) => {\n    if (depth > 1) return;\n    let entries: string[] = [];\n    try { entries = fs.readdirSync(d); } catch { return; }\n    for (const e of entries) {\n      if (e.startsWith(\".\") || e === \"bin\" || e === \"obj\") continue;\n      const full = path.join(d, e);\n      try {\n        const st = fs.statSync(full);\n        if (st.isDirectory()) walk(full, depth + 1);\n        else if (e.endsWith(\".csproj\")) found.push(full);\n      } catch { /* skip */ }\n    }\n  };\n  walk(dir, 0);\n  return found;\n}\n\n// A Windows project = a .sln or a .csproj in cwd or one level deep.\nfunction findWindowsProject(dir: string): boolean {\n  let entries: string[] = [];\n  try { entries = fs.readdirSync(dir); } catch { return false; }\n  if (entries.some((e) => e.endsWith(\".sln\"))) return true;\n  return findCsprojFiles(dir).length > 0;\n}\n\n// Win11 = WinUI 3 / .NET 10 (net10.0-windows); Win10 = WPF / .NET Framework 4.8 (net48).\n// Default to Windows 11 (the modern stack) when the signal is ambiguous.\nfunction detectWindowsFlavour(dir: string): \"windows11\" | \"windows10\" {\n  const blob = findCsprojFiles(dir).map((f) => {\n    try { return fs.readFileSync(f, \"utf-8\"); } catch { return \"\"; }\n  }).join(\"\\n\").toLowerCase();\n  if (blob.includes(\"net48\") || blob.includes(\"<usewpf>true\") || blob.includes(\"v4.8\")) return \"windows10\";\n  return \"windows11\";\n}\n\nfunction hasWindowsSDKDependency(dir: string): boolean {\n  return findCsprojFiles(dir).some((f) => {\n    try { return /Path\\.Terminal\\.Sdk/.test(fs.readFileSync(f, \"utf-8\")); } catch { return false; }\n  });\n}\n\n// \u2500\u2500\u2500 Summary helpers \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\nfunction platformLabel(platform: Platform): string {\n  switch (platform) {\n    case \"android\": return \"Android\";\n    case \"windows11\": return \"Windows 11 (WinUI 3 / .NET 10)\";\n    case \"windows10\": return \"Windows 10 (WPF / .NET FW 4.8)\";\n    default: return \"iOS\";\n  }\n}\n\nfunction printSummary(agent: AgentType, platform: Platform, actions: string[], warnings: string[], manualSteps: string[]) {\n  const isAndroid = platform === \"android\";\n  const isWindows = platform === \"windows11\" || platform === \"windows10\";\n  console.log(\"\\n\" + chalk.bold(\"\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\"));\n  console.log(chalk.bold(`  Path Terminal SDK \u2014 Setup Complete (${platformLabel(platform)})`));\n  console.log(chalk.bold(\"\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\\n\"));\n\n  if (actions.length > 0) {\n    console.log(chalk.green(\"\u2713 Done:\"));\n    actions.forEach((a) => console.log(chalk.green(`  \u2022 ${a}`)));\n    console.log();\n  }\n\n  if (manualSteps.length > 0) {\n    console.log(chalk.yellow(\"\u26A0 Manual steps required:\"));\n    manualSteps.forEach((s, i) => console.log(chalk.yellow(`  ${i + 1}. ${s}`)));\n    console.log();\n  }\n\n  if (warnings.length > 0) {\n    console.log(chalk.dim(\"\u2139 Notes:\"));\n    warnings.forEach((w) => console.log(chalk.dim(`  \u2022 ${w}`)));\n    console.log();\n  }\n\n  // Canonical first-prompt text \u2014 identical for Claude Code and Cursor so the\n  // agent receives the same directive regardless of the developer's IDE.\n  const mcpPrompt =\n    platform === \"android\" ? \"integrate-path-android\" :\n    platform === \"windows11\" ? \"integrate-path-windows11\" :\n    platform === \"windows10\" ? \"integrate-path-windows10\" :\n    \"integrate-path-sale\";\n  const firstPrompt =\n    '  \"Integrate the Path Terminal SDK into this EPOS app. Read CLAUDE.md\\n' +\n    '   for the integration rules, then use the Path MCP ' + mcpPrompt + '\\n' +\n    '   prompt to add a Path POS Adapter in Settings \u2014 a backend switcher for the\\n' +\n    '   Path POS Emulator (Wi-Fi/IP or Bluetooth) and a real Verifone terminal.\"';\n\n  if (agent === \"claude\") {\n    console.log(chalk.bold(\"\uD83D\uDE80 Start Claude Code in this directory:\"));\n    console.log(chalk.cyan(\"  claude --model sonnet\"));\n    console.log();\n    console.log(chalk.bold(\"  Then paste this prompt:\"));\n    console.log(chalk.cyan(firstPrompt));\n  } else {\n    console.log(chalk.bold(\"\uD83D\uDE80 Your first prompt in Cursor:\"));\n    console.log(chalk.cyan(firstPrompt));\n  }\n\n  console.log();\n  console.log(chalk.dim(`  MCP server: ${MCP_SERVER_URL}`));\n  console.log(chalk.dim(\"  Docs:       https://mcp.path2ai.tech/health\"));\n  console.log();\n}\n\n// \u2500\u2500\u2500 Main \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\nprogram\n  .name(\"path-terminal-init\")\n  .description(\n    \"Set up the Path Terminal SDK integration assistant for your EPOS project.\\n\" +\n      \"Auto-detects platform (iOS, Android, or Windows) from the current directory.\\n\" +\n      \"Configures MCP server access, drops the integration recipe, and optionally\\n\" +\n      \"adds the SDK dependency.\\n\\n\" +\n      \"Supported agents: claude (default), cursor\\n\" +\n      \"Supported platforms: ios (default), android, windows11 (WinUI 3 / .NET 10),\\n\" +\n      \"windows10 (WPF / .NET FW 4.8). Use 'windows' to auto-pick the Windows flavour.\"\n  )\n  .version(\"0.2.0\")\n  .option(\"--tools-only\", \"Only configure MCP + rules. Skip SDK installation.\")\n  .option(\"--agent <name>\", \"AI agent to configure: 'claude' (default) or 'cursor'.\", \"claude\")\n  .option(\"--platform <name>\", \"Platform: ios | android | windows | windows11 | windows10. Auto-detected if not specified.\")\n  .action(async (options) => {\n    const toolsOnly: boolean = options.toolsOnly ?? false;\n    const agent: AgentType = (options.agent ?? \"claude\") as AgentType;\n    const cwd = process.cwd();\n\n    // Auto-detect platform. Order: Android (Gradle) \u2192 Windows (.csproj/.sln) \u2192 iOS (default).\n    const rawPlatform: string = options.platform ?? \"auto\";\n    const VALID_PLATFORMS = [\"ios\", \"android\", \"windows\", \"windows11\", \"windows10\"];\n    let platform: Platform;\n    if (rawPlatform === \"auto\" || !VALID_PLATFORMS.includes(rawPlatform)) {\n      if (findAndroidProject(cwd)) platform = \"android\";\n      else if (findWindowsProject(cwd)) platform = detectWindowsFlavour(cwd);\n      else platform = \"ios\";\n    } else if (rawPlatform === \"windows\") {\n      // Explicit Windows, but let the .csproj decide Win11 (WinUI 3) vs Win10 (WPF).\n      platform = detectWindowsFlavour(cwd);\n    } else {\n      platform = rawPlatform as Platform;\n    }\n    const isAndroid = platform === \"android\";\n    const isWindows = platform === \"windows11\" || platform === \"windows10\";\n\n    console.log();\n    console.log(chalk.bold(\"  Path Terminal SDK \u2014 Integration Assistant Setup\"));\n    console.log(chalk.dim(\"  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\"));\n    console.log(chalk.dim(`  Agent:    ${agent}`));\n    console.log(chalk.dim(`  Platform: ${platform}${options.platform ? \"\" : \" (auto-detected)\"}`));\n    console.log();\n\n    if (agent !== \"cursor\" && agent !== \"claude\") {\n      console.log(\n        chalk.yellow(\n          `\u26A0 Agent '${agent}' is not supported. Use 'cursor' or 'claude'.`\n        )\n      );\n      process.exit(1);\n    }\n\n    const actions: string[] = [];\n    const warnings: string[] = [];\n    const manualSteps: string[] = [];\n\n    // \u2500\u2500 1. SDK installation \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    if (!toolsOnly) {\n      if (isAndroid) {\n        // \u2500\u2500 Android: JitPack + Gradle \u2500\u2500\n        const spinner = ora(\"Checking Android project\u2026\").start();\n\n        if (!findAndroidProject(cwd)) {\n          spinner.warn(\"No Android project found (settings.gradle.kts or app/build.gradle.kts missing).\");\n          const answer = await ask(\n            chalk.yellow(\"  Continue with tools-only setup? (y/n): \")\n          );\n          if (answer.toLowerCase() !== \"y\") {\n            console.log(chalk.dim(\"\\n  Run this from your Android project root directory.\\n\"));\n            process.exit(0);\n          }\n          warnings.push(\"Ran in tools-only mode \u2014 no Android project found.\");\n        } else if (hasAndroidSDKDependency(cwd)) {\n          spinner.succeed(\"Path Terminal SDK already present in settings.gradle.kts.\");\n          actions.push(\"SDK dependency already present \u2014 no change needed.\");\n        } else {\n          spinner.text = \"Adding JitPack repository to settings.gradle.kts\u2026\";\n          const settingsOk = injectJitPackRepo(cwd);\n          const depsOk = injectGradleDependencies(cwd);\n\n          if (settingsOk) {\n            spinner.succeed(\"JitPack repository added to settings.gradle.kts.\");\n            actions.push(\"JitPack repository added to settings.gradle.kts\");\n          }\n          if (depsOk) {\n            spinner.succeed(\"SDK dependencies added to app/build.gradle.kts.\");\n            actions.push(\"path-terminal-sdk + path-emulator-adapter added to app/build.gradle.kts\");\n          } else {\n            spinner.warn(\"Could not auto-inject dependencies into app/build.gradle.kts.\");\n            manualSteps.push(\n              `Add to app/build.gradle.kts dependencies {}:\\n` +\n              `     implementation(\"${ANDROID_SDK_JITPACK_GROUP}:path-terminal-sdk:${ANDROID_SDK_JITPACK_VERSION}\")\\n` +\n              `     implementation(\"${ANDROID_SDK_JITPACK_GROUP}:path-emulator-adapter:${ANDROID_SDK_JITPACK_VERSION}\")`\n            );\n          }\n        }\n      } else if (isWindows) {\n        // \u2500\u2500 Windows: ProjectReference to the sibling SDK \u2500\u2500\n        const spinner = ora(\"Checking Windows (.NET) project\u2026\").start();\n        if (!findWindowsProject(cwd)) {\n          spinner.warn(\"No Windows project found (.sln or .csproj).\");\n          const answer = await ask(chalk.yellow(\"  Continue with tools-only setup? (y/n): \"));\n          if (answer.toLowerCase() !== \"y\") {\n            console.log(chalk.dim(\"\\n  Run this from your Windows EPOS project root.\\n\"));\n            process.exit(0);\n          }\n          warnings.push(\"Ran in tools-only mode \u2014 no Windows project found.\");\n        } else if (hasWindowsSDKDependency(cwd)) {\n          spinner.succeed(\"Path Terminal SDK already referenced in the project.\");\n          actions.push(\"SDK ProjectReference already present \u2014 no change needed.\");\n        } else {\n          spinner.info(\"Path SDK is wired by ProjectReference \u2014 the integration recipe (Step 0) does this.\");\n          manualSteps.push(\n            `Add the Path SDK ProjectReferences to your .csproj \u2014 the integration recipe's Step 0 lists all six ` +\n            `(CoreModels, Sdk, EmulatorAdapter, MockAdapter, Diagnostics, PsdkAdapter). ` +\n            `Clone ${WINDOWS_SDK_REPO} as a SIBLING folder of this project first.`\n          );\n        }\n      } else {\n        // \u2500\u2500 iOS: SPM / Xcode \u2500\u2500\n        const spinner = ora(\"Checking for Xcode project\u2026\").start();\n\n        const xcodeProject = findXcodeProject(cwd);\n        const packageSwift = findPackageSwift(cwd);\n\n        if (packageSwift) {\n          spinner.text = \"Found Package.swift \u2014 adding PathTerminalSDK dependency\u2026\";\n          if (hasSDKDependency(packageSwift)) {\n            spinner.succeed(\"PathTerminalSDK already present in Package.swift.\");\n            actions.push(\"PathTerminalSDK dependency already present \u2014 no change needed.\");\n          } else {\n            const injected = injectSPMDependency(packageSwift);\n            if (injected) {\n              spinner.succeed(\"PathTerminalSDK added to Package.swift.\");\n              actions.push(\"PathTerminalSDK added to Package.swift\");\n              manualSteps.push(\n                `Open Xcode and link all three targets to your app: PathTerminalSDK, PathEmulatorAdapter, PathCoreModels.`\n              );\n            } else {\n              spinner.warn(\"Could not automatically modify Package.swift \u2014 manual step required.\");\n              manualSteps.push(\n                `Add PathTerminalSDK manually to Package.swift:\\n` +\n                  `     .package(url: \"${SDK_GITHUB_URL}\", from: \"${SDK_VERSION}\")`\n              );\n            }\n          }\n        } else if (xcodeProject) {\n          spinner.succeed(`Found Xcode project: ${path.basename(xcodeProject)}`);\n          if (hasXcodeProjectSDKDependency(xcodeProject)) {\n            spinner.succeed(\"PathTerminalSDK already present in Xcode project.\");\n            actions.push(\"PathTerminalSDK dependency already present \u2014 no change needed.\");\n          } else {\n            console.log(\n              chalk.yellow(\n                \"\\n  \u26A0 Automatic SPM injection into .xcodeproj is not supported (Xcode manages this).\"\n              )\n            );\n            console.log(chalk.bold(\"\\n  To add PathTerminalSDK in Xcode:\"));\n            console.log(\"  1. Open your project in Xcode\");\n            console.log(\"  2. File \u2192 Add Package Dependencies\u2026\");\n            console.log(`  3. Enter URL: ${chalk.cyan(SDK_GITHUB_URL)}`);\n            console.log(\n              \"  4. In the 'Choose Package Products' dialog, set all three to your app target:\"\n            );\n            console.log(chalk.cyan(\"       PathTerminalSDK    \u2192 your app target\"));\n            console.log(chalk.cyan(\"       PathEmulatorAdapter \u2192 your app target\"));\n            console.log(chalk.cyan(\"       PathCoreModels      \u2192 your app target\"));\n            console.log(chalk.dim(\"     (PathDiagnostics can be left as None)\"));\n            console.log(\"  5. Click Add Package\\n\");\n            const confirmed = await ask(\n              chalk.bold(\"  Press Enter once you have added the package, or type 'skip' to do this later: \")\n            );\n            if (confirmed.toLowerCase() !== \"skip\") {\n              actions.push(`PathTerminalSDK added to Xcode project (confirmed by user)`);\n            } else {\n              manualSteps.push(\n                `Add PathTerminalSDK via Xcode: File \u2192 Add Package Dependencies \u2192 ${SDK_GITHUB_URL}`\n              );\n            }\n          }\n        } else {\n          spinner.warn(\"No Xcode project found in current directory.\");\n          const answer = await ask(\n            chalk.yellow(\n              \"  No .xcodeproj or Package.swift found. Continue with tools-only setup? (y/n): \"\n            )\n          );\n          if (answer.toLowerCase() !== \"y\") {\n            console.log(\n              chalk.dim(\"\\n  Run this command from your Xcode project directory, or use --tools-only.\\n\")\n            );\n            process.exit(0);\n          }\n          warnings.push(\"Ran in tools-only mode \u2014 no Xcode project found.\");\n        }\n      }\n    } else {\n      actions.push(\"Skipped SDK installation (--tools-only mode)\");\n    }\n\n    // \u2500\u2500 2. MCP config \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    {\n      const spinner = ora(\"Writing MCP server config\u2026\").start();\n\n      let result: { written: boolean; merged: boolean };\n      let configFile: string;\n\n      if (agent === \"claude\") {\n        result = writeClaudeMcpConfig(cwd);\n        configFile = \".mcp.json\";\n      } else {\n        result = writeCursorMcpConfig(cwd);\n        configFile = \".cursor/mcp.json\";\n      }\n\n      if (result.written && result.merged) {\n        spinner.succeed(`MCP config merged into existing ${configFile}.`);\n        actions.push(`path-terminal entry merged into ${configFile}`);\n      } else if (result.written) {\n        spinner.succeed(`MCP config written to ${configFile}.`);\n        actions.push(`MCP server configured: ${configFile}`);\n      } else {\n        spinner.info(\"MCP config already present \u2014 no change needed.\");\n        actions.push(\"MCP config already present \u2014 no change needed.\");\n      }\n\n      // For Claude Code, also pre-approve the MCP server in .claude/settings.json.\n      // Without this, Claude Code shows an interactive \"Allow this MCP server?\"\n      // prompt on first launch \u2014 easy to miss, and the agent ends up running\n      // without MCP tools if the user dismisses it.\n      if (agent === \"claude\") {\n        const approveSpinner = ora(\"Pre-approving Path MCP server for Claude Code\u2026\").start();\n        const approve = writeClaudeSettings(cwd);\n        if (approve.alreadyApproved) {\n          approveSpinner.info(\"Path MCP server already pre-approved \u2014 no change needed.\");\n        } else if (approve.written && approve.merged) {\n          approveSpinner.succeed(\"path-terminal added to existing .claude/settings.json.\");\n          actions.push(\"path-terminal pre-approved in .claude/settings.json\");\n        } else if (approve.written) {\n          approveSpinner.succeed(\"Pre-approval written to .claude/settings.json.\");\n          actions.push(\"Claude Code pre-approval: .claude/settings.json\");\n        } else {\n          approveSpinner.warn(\"Could not write .claude/settings.json \u2014 you may see an \\\"Allow MCP server?\\\" prompt on first Claude Code launch. Accept it.\");\n        }\n      }\n    }\n\n    // \u2500\u2500 3. Rules file \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    {\n      const spinner = ora(`Writing ${agent === \"claude\" ? \"CLAUDE.md\" : \"Cursor rules\"} file\u2026`).start();\n\n      let result: { written: boolean; skipped: boolean };\n      let rulesFile: string;\n\n      // Per-platform recipe source + fetch URL + filename.\n      const rulesByPlatform = {\n        ios:       { src: RULES_SOURCE,          url: RULES_FETCH_URL,          file: \"path-integration.mdc\" },\n        android:   { src: ANDROID_RULES_SOURCE,   url: ANDROID_RULES_FETCH_URL,   file: \"path-integration-android.mdc\" },\n        windows11: { src: WINDOWS11_RULES_SOURCE, url: WINDOWS11_RULES_FETCH_URL, file: \"path-integration-windows11.mdc\" },\n        windows10: { src: WINDOWS10_RULES_SOURCE, url: WINDOWS10_RULES_FETCH_URL, file: \"path-integration-windows10.mdc\" },\n      } as const;\n      const activeRules = rulesByPlatform[platform];\n      const activeFetchUrl = activeRules.url;\n\n      if (agent === \"claude\") {\n        result = writeClaudeRulesFile(cwd, activeRules.src, activeFetchUrl);\n        rulesFile = \"CLAUDE.md\";\n      } else {\n        result = writeCursorRulesFile(cwd, activeRules.src, activeRules.file, activeFetchUrl);\n        rulesFile = `.cursor/rules/${activeRules.file}`;\n      }\n\n      if (result.written) {\n        spinner.succeed(`Rules file written to ${rulesFile}.`);\n        actions.push(`Integration rules file: ${rulesFile}`);\n      } else if (result.skipped) {\n        spinner.info(\n          `${rulesFile} already exists \u2014 skipped to preserve your customisations.`\n        );\n        warnings.push(\n          `${rulesFile} already exists \u2014 not overwritten.`\n        );\n      } else {\n        spinner.warn(\"Could not write rules file \u2014 check network connectivity.\");\n        manualSteps.push(\n          `Download ${activeRules.file} manually from: ${activeFetchUrl}`\n        );\n      }\n    }\n\n    // \u2500\u2500 4. Permission check \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    if (!toolsOnly) {\n      if (isAndroid) {\n        const spinner = ora(\"Checking AndroidManifest.xml BLE permissions\u2026\").start();\n        const manifestsWithIssues = checkAndroidManifest(cwd);\n        if (manifestsWithIssues.length === 0) {\n          spinner.succeed(\"BLE permissions found in AndroidManifest.xml.\");\n          actions.push(\"BLE permissions verified in AndroidManifest.xml\");\n        } else {\n          spinner.warn(\n            `BLUETOOTH_SCAN missing from ${manifestsWithIssues.length} AndroidManifest.xml file(s).`\n          );\n          manifestsWithIssues.forEach((p) => {\n            const relative = path.relative(cwd, p);\n            manualSteps.push(\n              `Add BLE permissions to ${relative}:\\n` +\n              `     (Ask the MCP: \"get_manifest_requirements\" for the full XML)`\n            );\n          });\n        }\n      } else if (isWindows) {\n        // Windows reaches BLE via WinRT \u2014 no manifest capability to add (unpackaged\n        // WinUI 3 / WPF). The Wi-Fi/IP and Verifone backends use no Bluetooth at all.\n        actions.push(\"Bluetooth needs no manifest entry on Windows (WinRT).\");\n      } else {\n        const spinner = ora(\"Checking Info.plist BLE permissions\u2026\").start();\n        const plistsWithIssues = checkInfoPlist(cwd);\n        if (plistsWithIssues.length === 0) {\n          spinner.succeed(\"BLE permissions found in Info.plist.\");\n          actions.push(\"BLE permissions verified in Info.plist\");\n        } else {\n          spinner.warn(\n            `NSBluetoothAlwaysUsageDescription missing from ${plistsWithIssues.length} Info.plist file(s).`\n          );\n          plistsWithIssues.forEach((p) => {\n            const relative = path.relative(cwd, p);\n            manualSteps.push(\n              `Add BLE permission to ${relative}:\\n` +\n                `     <key>NSBluetoothAlwaysUsageDescription</key>\\n` +\n                `     <string>This app connects to a Path payment terminal via Bluetooth.</string>\\n` +\n                `     (Ask the MCP: \"get_info_plist_requirements\" for the full XML)`\n            );\n          });\n        }\n      }\n    }\n\n    // \u2500\u2500 5. Summary \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    printSummary(agent, platform, actions, warnings, manualSteps);\n  });\n\nprogram.parse(process.argv);\n"],
  "mappings": "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",
  "names": ["rules", "chalk", "ora"]
}
