@simplysm/sd-cli 13.0.100 → 14.0.1

package/dist/capacitor/capacitor.js

@@ -1,694 +0,0 @@
-import path from "path";
-import { fsx } from "@simplysm/core-node";
-import { env } from "@simplysm/core-common";
-import { consola } from "consola";
-import sharp from "sharp";
-import { execa } from "execa";
-class CapacitorConfigError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "CapacitorConfigError";
-  }
-}
-class Capacitor {
-  constructor(_pkgPath, _config, npmConfig, _exclude) {
-    this._pkgPath = _pkgPath;
-    this._config = _config;
-    this._exclude = _exclude;
-    this._platforms = Object.keys(this._config.platform ?? {});
-    this._npmConfig = npmConfig;
-    this._capPath = path.resolve(this._pkgPath, ".capacitor");
-  }
-  static _ANDROID_KEYSTORE_FILE_NAME = "android.keystore";
-  static _LOCK_FILE_NAME = ".capacitor.lock";
-  static _logger = consola.withTag("sd:cli:capacitor");
-  static _utf8Decoder = new TextDecoder("utf-8", { fatal: true });
-  static _fallbackDecoder = new TextDecoder("euc-kr");
-  _capPath;
-  _platforms;
-  _npmConfig;
-  /**
-   * Create Capacitor instance (with configuration validation)
-   */
-  static async create(pkgPath, config, exclude) {
-    Capacitor._validateConfig(config);
-    const npmConfig = await fsx.readJson(path.resolve(pkgPath, "package.json"));
-    return new Capacitor(pkgPath, config, npmConfig, exclude ?? []);
-  }
-  /**
-   * F5: Validate configuration
-   */
-  static _validateConfig(config) {
-    if (typeof config.appId !== "string" || config.appId.trim() === "") {
-      throw new CapacitorConfigError("capacitor.appId is required.");
-    }
-    if (!/^[a-z][a-z0-9_]*(\.[a-z][a-z0-9_]*)+$/i.test(config.appId)) {
-      throw new CapacitorConfigError(`capacitor.appId format is invalid: ${config.appId}`);
-    }
-    if (typeof config.appName !== "string" || config.appName.trim() === "") {
-      throw new CapacitorConfigError("capacitor.appName is required.");
-    }
-    if (!/^[\p{L}\p{N} \-]+$/u.test(config.appName)) {
-      throw new CapacitorConfigError(`capacitor.appName contains invalid characters: ${config.appName}`);
-    }
-    if (config.platform != null) {
-      const platforms = Object.keys(config.platform);
-      for (const p of platforms) {
-        if (p !== "android") {
-          throw new CapacitorConfigError(`unsupported platform: ${p} (currently only android is supported)`);
-        }
-      }
-    }
-  }
-  /**
-   * Execute a Capacitor CLI command via npx
-   */
-  async _execCap(args) {
-    return this._exec("npx", ["cap", ...args], this._capPath);
-  }
-  /**
-   * Execute capacitor-assets CLI command via npx
-   */
-  async _execCapAssets(args) {
-    return this._exec("npx", ["capacitor-assets", ...args], this._capPath);
-  }
-  /**
-   * Execute command (with logging)
-   */
-  async _exec(cmd, args, cwd) {
-    Capacitor._logger.debug(`executed command: ${cmd} ${args.join(" ")}`);
-    const result = await execa(cmd, args, { cwd, reject: false, encoding: "buffer" });
-    const stdout = Capacitor._decodeOutput(result.stdout);
-    if (result.exitCode !== 0) {
-      const stderr = Capacitor._decodeOutput(result.stderr);
-      throw new Error(`${cmd} ${args.join(" ")} failed (exit ${result.exitCode}): ${stderr || stdout}`);
-    }
-    Capacitor._logger.debug(`execution result: ${stdout}`);
-    return stdout;
-  }
-  /**
-   * Decode command output (UTF-8 first, fallback to EUC-KR for Windows CP949)
-   */
-  static _decodeOutput(bytes) {
-    try {
-      return Capacitor._utf8Decoder.decode(bytes);
-    } catch {
-      return Capacitor._fallbackDecoder.decode(bytes);
-    }
-  }
-  /**
-   * F10: Acquire lock to prevent concurrent execution
-   */
-  async _acquireLock() {
-    const lockPath = path.resolve(this._capPath, Capacitor._LOCK_FILE_NAME);
-    if (await fsx.exists(lockPath)) {
-      const lockContent = await fsx.read(lockPath);
-      throw new Error(
-        `Another Capacitor operation is in progress (PID: ${lockContent}). If there's an issue, delete the ${lockPath} file.`
-      );
-    }
-    await fsx.mkdir(this._capPath);
-    await fsx.write(lockPath, String(process.pid));
-  }
-  /**
-   * F10: Release lock
-   */
-  async _releaseLock() {
-    const lockPath = path.resolve(this._capPath, Capacitor._LOCK_FILE_NAME);
-    await fsx.rm(lockPath);
-  }
-  /**
-   * F4: Validate external tools
-   */
-  async _validateTools() {
-    const sdkPath = await this._findAndroidSdk();
-    if (sdkPath == null) {
-      throw new Error(
-        "Android SDK not found.\n1. Install Android Studio or\n2. Set ANDROID_HOME or ANDROID_SDK_ROOT environment variable."
-      );
-    }
-    if (this._platforms.includes("android")) {
-      const javaPath = await this._findJava21();
-      if (javaPath == null) {
-        Capacitor._logger.warn(
-          "Java 21 not found. Gradle may use embedded JDK or the build may fail."
-        );
-      }
-    }
-  }
-  /**
-   * Initialize Capacitor project
-   *
-   * 1. Create package.json and install dependencies
-   * 2. Create capacitor.config.ts
-   * 3. Add platform (android)
-   * 4. Set up icon
-   * 5. Configure Android native settings
-   * 6. Run cap sync or cap copy
-   */
-  async initialize() {
-    await this._acquireLock();
-    try {
-      await this._validateTools();
-      const changed = await this._initCap();
-      await this._writeCapConf();
-      await this._addPlatforms();
-      await this._setupIcon();
-      if (this._platforms.includes("android")) {
-        await this._configureAndroid();
-      }
-      if (changed) {
-        await this._execCap(["sync"]);
-      } else {
-        await this._execCap(["copy"]);
-      }
-    } finally {
-      await this._releaseLock();
-    }
-  }
-  /**
-   * Build Android APK/AAB
-   */
-  async build(outPath) {
-    await this._acquireLock();
-    try {
-      const buildType = this._config.debug ? "debug" : "release";
-      for (const platform of this._platforms) {
-        await this._execCap(["copy", platform]);
-        if (platform === "android") {
-          await this._buildAndroid(outPath, buildType);
-        } else {
-          throw new Error(`unsupported platform: ${platform}`);
-        }
-      }
-    } finally {
-      await this._releaseLock();
-    }
-  }
-  /**
-   * Run app on device (connect WebView to development server)
-   */
-  async runOnDevice(url) {
-    if (url != null) {
-      this._validateUrl(url);
-      await this._updateServerUrl(url);
-    }
-    for (const platform of this._platforms) {
-      await this._execCap(["copy", platform]);
-      try {
-        await this._execCap(["run", platform]);
-      } catch (err) {
-        if (platform === "android") {
-          try {
-            await this._exec("adb", ["kill-server"], this._capPath);
-          } catch {
-          }
-        }
-        throw err;
-      }
-    }
-  }
-  /**
-   * F11: Validate URL
-   */
-  _validateUrl(url) {
-    try {
-      const parsed = new URL(url);
-      if (!["http:", "https:"].includes(parsed.protocol)) {
-        throw new Error(`unsupported protocol: ${parsed.protocol}`);
-      }
-    } catch (err) {
-      if (err instanceof TypeError) {
-        throw new Error(`invalid URL: ${url}`);
-      }
-      throw err;
-    }
-  }
-  //#region Private - Initialization
-  /**
-   * Basic Capacitor project initialization (package.json, pnpm install, cap init)
-   */
-  async _initCap() {
-    const depChanged = await this._setupNpmConf();
-    const nodeModulesExists = await fsx.exists(path.resolve(this._capPath, "node_modules"));
-    if (!depChanged && nodeModulesExists) return false;
-    const installResult = await this._exec("npm", ["install"], this._capPath);
-    Capacitor._logger.debug(`npm install completed: ${installResult}`);
-    const configPath = path.resolve(this._capPath, "capacitor.config.ts");
-    if (!await fsx.exists(configPath)) {
-      await this._execCap(["init", this._config.appId, this._config.appId]);
-    }
-    const wwwPath = path.resolve(this._capPath, "www");
-    await fsx.mkdir(wwwPath);
-    await fsx.write(
-      path.resolve(wwwPath, "index.html"),
-      "<!DOCTYPE html><html><head></head><body></body></html>"
-    );
-    return true;
-  }
-  /**
-   * Configure package.json
-   */
-  async _setupNpmConf() {
-    const projNpmConfigPath = path.resolve(this._pkgPath, "../../package.json");
-    if (!await fsx.exists(projNpmConfigPath)) {
-      throw new Error(`root package.json not found: ${projNpmConfigPath}`);
-    }
-    const projNpmConfig = await fsx.readJson(projNpmConfigPath);
-    const capNpmConfPath = path.resolve(this._capPath, "package.json");
-    const orgCapNpmConf = await fsx.exists(capNpmConfPath) ? await fsx.readJson(capNpmConfPath) : { name: "", version: "" };
-    const capNpmConf = { ...orgCapNpmConf };
-    capNpmConf.name = this._config.appId;
-    capNpmConf.version = this._npmConfig.version;
-    if (projNpmConfig.volta != null) {
-      capNpmConf.volta = projNpmConfig.volta;
-    }
-    capNpmConf.dependencies = capNpmConf.dependencies ?? {};
-    capNpmConf.dependencies["@capacitor/core"] = "^7.0.0";
-    capNpmConf.dependencies["@capacitor/app"] = "^7.0.0";
-    for (const platform of this._platforms) {
-      capNpmConf.dependencies[`@capacitor/${platform}`] = "^7.0.0";
-    }
-    capNpmConf.devDependencies = capNpmConf.devDependencies ?? {};
-    capNpmConf.devDependencies["@capacitor/cli"] = "^7.0.0";
-    capNpmConf.devDependencies["@capacitor/assets"] = "^3.0.0";
-    const mainDeps = {
-      ...this._npmConfig.dependencies,
-      ...this._npmConfig.devDependencies,
-      ...this._npmConfig.peerDependencies
-    };
-    const usePlugins = Object.keys(this._config.plugins ?? {});
-    const prevPlugins = Object.keys(capNpmConf.dependencies).filter(
-      (item) => !["@capacitor/core", "@capacitor/android", "@capacitor/ios", "@capacitor/app"].includes(
-        item
-      )
-    );
-    for (const prevPlugin of prevPlugins) {
-      if (!usePlugins.includes(prevPlugin)) {
-        delete capNpmConf.dependencies[prevPlugin];
-        Capacitor._logger.debug(`plugin removed: ${prevPlugin}`);
-      }
-    }
-    for (const plugin of usePlugins) {
-      if (!(plugin in capNpmConf.dependencies)) {
-        const version = mainDeps[plugin] ?? "*";
-        capNpmConf.dependencies[plugin] = version;
-        Capacitor._logger.debug(`plugin added: ${plugin}@${version}`);
-      }
-    }
-    for (const excludePkg of this._exclude) {
-      if (!(excludePkg in capNpmConf.dependencies)) {
-        const version = mainDeps[excludePkg] ?? "*";
-        capNpmConf.dependencies[excludePkg] = version;
-        Capacitor._logger.debug(`exclude package added: ${excludePkg}@${version}`);
-      }
-    }
-    await fsx.mkdir(this._capPath);
-    await fsx.writeJson(capNpmConfPath, capNpmConf, { space: 2 });
-    const isChanged = orgCapNpmConf.volta !== capNpmConf.volta || JSON.stringify(orgCapNpmConf.dependencies) !== JSON.stringify(capNpmConf.dependencies) || JSON.stringify(orgCapNpmConf.devDependencies) !== JSON.stringify(capNpmConf.devDependencies);
-    return isChanged;
-  }
-  /**
-   * Create capacitor.config.ts
-   */
-  async _writeCapConf() {
-    const confPath = path.resolve(this._capPath, "capacitor.config.ts");
-    const pluginOptions = {};
-    for (const [pluginName, options] of Object.entries(this._config.plugins ?? {})) {
-      if (options !== true) {
-        const configKey = this._toPascalCase(pluginName.split("/").at(-1));
-        pluginOptions[configKey] = options;
-      }
-    }
-    const pluginsConfigStr = Object.keys(pluginOptions).length > 0 ? JSON.stringify(pluginOptions, null, 2).replace(/^/gm, "  ").trim() : "{}";
-    const configContent = `import type { CapacitorConfig } from "@capacitor/cli";
-
-const config: CapacitorConfig = {
-  appId: "${this._config.appId}",
-  appName: "${this._config.appName}",
-  server: {
-    androidScheme: "http",
-    cleartext: true
-  },
-  android: {},
-  plugins: ${pluginsConfigStr},
-};
-
-export default config;
-`;
-    await fsx.write(confPath, configContent);
-  }
-  /**
-   * Add platform (F12: ensure idempotency)
-   */
-  async _addPlatforms() {
-    for (const platform of this._platforms) {
-      const platformPath = path.resolve(this._capPath, platform);
-      if (await fsx.exists(platformPath)) {
-        Capacitor._logger.debug(`platform already exists: ${platform}`);
-        continue;
-      }
-      await this._execCap(["add", platform]);
-    }
-  }
-  /**
-   * Set up icon (F6: error recovery)
-   */
-  async _setupIcon() {
-    const assetsDirPath = path.resolve(this._capPath, "assets");
-    if (this._config.icon != null) {
-      const iconSource = path.resolve(this._pkgPath, this._config.icon);
-      if (!await fsx.exists(iconSource)) {
-        Capacitor._logger.warn(
-          `icon file not found: ${iconSource}. Using default icon.`
-        );
-        return;
-      }
-      try {
-        await fsx.mkdir(assetsDirPath);
-        const logoPath = path.resolve(assetsDirPath, "logo.png");
-        const logoSize = Math.floor(1024 * 0.6);
-        const padding = Math.floor((1024 - logoSize) / 2);
-        await sharp(iconSource).resize(logoSize, logoSize, {
-          fit: "contain",
-          background: { r: 0, g: 0, b: 0, alpha: 0 }
-        }).extend({
-          top: padding,
-          bottom: padding,
-          left: padding,
-          right: padding,
-          background: { r: 0, g: 0, b: 0, alpha: 0 }
-        }).toFile(logoPath);
-        await this._execCapAssets([
-          "generate",
-          "--iconBackgroundColor",
-          "#ffffff",
-          "--splashBackgroundColor",
-          "#ffffff"
-        ]);
-      } catch (err) {
-        Capacitor._logger.warn(
-          `icon generation failed: ${err instanceof Error ? err.message : err}. Using default icon.`
-        );
-      }
-    } else {
-      await fsx.rm(assetsDirPath);
-    }
-  }
-  //#endregion
-  //#region Private - Android Configuration
-  /**
-   * Configure Android native settings
-   */
-  async _configureAndroid() {
-    const androidPath = path.resolve(this._capPath, "android");
-    if (!await fsx.exists(androidPath)) {
-      throw new Error(`Android project directory not found: ${androidPath}`);
-    }
-    await this._configureAndroidJavaHomePath(androidPath);
-    await this._configureAndroidSdkPath(androidPath);
-    await this._configureAndroidManifest(androidPath);
-    await this._configureAndroidBuildGradle(androidPath);
-  }
-  /**
-   * Set up JAVA_HOME path (gradle.properties)
-   */
-  async _configureAndroidJavaHomePath(androidPath) {
-    const gradlePropsPath = path.resolve(androidPath, "gradle.properties");
-    if (!await fsx.exists(gradlePropsPath)) {
-      Capacitor._logger.warn(`gradle.properties file not found: ${gradlePropsPath}`);
-      return;
-    }
-    let content = await fsx.read(gradlePropsPath);
-    const java21Path = await this._findJava21();
-    if (java21Path != null && !content.includes("org.gradle.java.home")) {
-      const escapedPath = java21Path.replace(/\\/g, "\\\\");
-      content += `
-org.gradle.java.home=${escapedPath}
-`;
-      await fsx.write(gradlePropsPath, content);
-    }
-  }
-  /**
-   * Auto-detect Java 21 path
-   */
-  async _findJava21() {
-    const patterns = [
-      "C:/Program Files/Amazon Corretto/jdk21*",
-      "C:/Program Files/Eclipse Adoptium/jdk-21*",
-      "C:/Program Files/Java/jdk-21*",
-      "C:/Program Files/Microsoft/jdk-21*",
-      "/usr/lib/jvm/java-21*",
-      "/usr/lib/jvm/temurin-21*"
-    ];
-    for (const pattern of patterns) {
-      const matches = await fsx.glob(pattern);
-      if (matches.length > 0) {
-        return matches.sort().at(-1);
-      }
-    }
-    return void 0;
-  }
-  /**
-   * Set up Android SDK path (local.properties)
-   */
-  async _configureAndroidSdkPath(androidPath) {
-    const localPropsPath = path.resolve(androidPath, "local.properties");
-    const sdkPath = await this._findAndroidSdk();
-    if (sdkPath != null) {
-      await fsx.write(localPropsPath, `sdk.dir=${sdkPath.replace(/\\/g, "/")}
-`);
-    } else {
-      throw new Error(
-        "Android SDK not found.\n1. Install Android Studio or\n2. Set ANDROID_HOME or ANDROID_SDK_ROOT environment variable."
-      );
-    }
-  }
-  /**
-   * Search for Android SDK path
-   */
-  async _findAndroidSdk() {
-    const fromEnv = env["ANDROID_HOME"] ?? env["ANDROID_SDK_ROOT"];
-    if (fromEnv != null && await fsx.exists(fromEnv)) {
-      return fromEnv;
-    }
-    const candidates = [
-      path.resolve(env["LOCALAPPDATA"] ?? "", "Android/Sdk"),
-      path.resolve(env["HOME"] ?? "", "Android/Sdk"),
-      "C:/Program Files/Android/Sdk",
-      "C:/Android/Sdk"
-    ];
-    for (const candidate of candidates) {
-      if (await fsx.exists(candidate)) {
-        return candidate;
-      }
-    }
-    return void 0;
-  }
-  /**
-   * Modify AndroidManifest.xml (F3: add error handling)
-   */
-  async _configureAndroidManifest(androidPath) {
-    const manifestPath = path.resolve(androidPath, "app/src/main/AndroidManifest.xml");
-    if (!await fsx.exists(manifestPath)) {
-      throw new Error(`AndroidManifest.xml file not found: ${manifestPath}`);
-    }
-    let content = await fsx.read(manifestPath);
-    if (!content.includes("android:usesCleartextTraffic")) {
-      content = content.replace("<application", '<application android:usesCleartextTraffic="true"');
-    }
-    const permissions = this._config.platform?.android?.permissions ?? [];
-    for (const perm of permissions) {
-      const permTag = `<uses-permission android:name="android.permission.${perm.name}"`;
-      if (!content.includes(permTag)) {
-        const maxSdkAttr = perm.maxSdkVersion != null ? ` android:maxSdkVersion="${perm.maxSdkVersion}"` : "";
-        const ignoreAttr = perm.ignore != null ? ` tools:ignore="${perm.ignore}"` : "";
-        const permLine = `    ${permTag}${maxSdkAttr}${ignoreAttr} />
-`;
-        if (perm.ignore != null && !content.includes("xmlns:tools=")) {
-          content = content.replace(
-            "<manifest xmlns:android",
-            '<manifest xmlns:tools="http://schemas.android.com/tools" xmlns:android'
-          );
-        }
-        content = content.replace("</manifest>", `${permLine}</manifest>`);
-      }
-    }
-    const appConfig = this._config.platform?.android?.config;
-    if (appConfig) {
-      for (const [key, value] of Object.entries(appConfig)) {
-        const attr = `android:${key}="${value}"`;
-        if (!content.includes(`android:${key}=`)) {
-          content = content.replace("<application", `<application ${attr}`);
-        }
-      }
-    }
-    const intentFilters = this._config.platform?.android?.intentFilters ?? [];
-    for (const filter of intentFilters) {
-      const filterKey = filter.action ?? filter.category ?? "";
-      if (filterKey && !content.includes(filterKey)) {
-        const actionLine = filter.action != null ? `<action android:name="${filter.action}"/>` : "";
-        const categoryLine = filter.category != null ? `<category android:name="${filter.category}"/>` : "";
-        content = content.replace(
-          /(<activity[\s\S]*?android:name="\.MainActivity"[\s\S]*?>)/,
-          `$1
-            <intent-filter>
-                ${actionLine}
-                ${categoryLine}
-            </intent-filter>`
-        );
-      }
-    }
-    await fsx.write(manifestPath, content);
-  }
-  /**
-   * Modify build.gradle (F3: add error handling)
-   */
-  async _configureAndroidBuildGradle(androidPath) {
-    const buildGradlePath = path.resolve(androidPath, "app/build.gradle");
-    if (!await fsx.exists(buildGradlePath)) {
-      throw new Error(`build.gradle file not found: ${buildGradlePath}`);
-    }
-    let content = await fsx.read(buildGradlePath);
-    const version = this._npmConfig.version;
-    const cleanVersion = version.replace(/-.*$/, "");
-    const versionParts = cleanVersion.split(".");
-    const versionCode = parseInt(versionParts[0] ?? "0") * 1e4 + parseInt(versionParts[1] ?? "0") * 100 + parseInt(versionParts[2] ?? "0");
-    content = content.replace(/versionCode \d+/, `versionCode ${versionCode}`);
-    content = content.replace(/versionName "[^"]+"/, `versionName "${version}"`);
-    if (this._config.platform?.android?.sdkVersion != null) {
-      const sdkVersion = this._config.platform.android.sdkVersion;
-      content = content.replace(/minSdkVersion .+/, `minSdkVersion ${sdkVersion}`);
-      content = content.replace(/targetSdkVersion .+/, `targetSdkVersion ${sdkVersion}`);
-    } else {
-      content = content.replace(/minSdkVersion .+/, `minSdkVersion rootProject.ext.minSdkVersion`);
-      content = content.replace(
-        /targetSdkVersion .+/,
-        `targetSdkVersion rootProject.ext.targetSdkVersion`
-      );
-    }
-    const keystorePath = path.resolve(this._capPath, Capacitor._ANDROID_KEYSTORE_FILE_NAME);
-    const signConfig = this._config.platform?.android?.sign;
-    if (signConfig) {
-      const keystoreSource = path.resolve(this._pkgPath, signConfig.keystore);
-      if (!await fsx.exists(keystoreSource)) {
-        throw new Error(`keystore file not found: ${keystoreSource}`);
-      }
-      await fsx.copy(keystoreSource, keystorePath);
-      const keystoreRelativePath = path.relative(path.dirname(buildGradlePath), keystorePath).replace(/\\/g, "/");
-      const keystoreType = signConfig.keystoreType ?? "jks";
-      if (!content.includes("signingConfigs")) {
-        const signingConfigsBlock = `
-    signingConfigs {
-        release {
-            storeFile file("${keystoreRelativePath}")
-            storePassword '${Capacitor._escapeGroovyString(signConfig.storePassword)}'
-            keyAlias '${Capacitor._escapeGroovyString(signConfig.alias)}'
-            keyPassword '${Capacitor._escapeGroovyString(signConfig.password)}'
-            storeType "${keystoreType}"
-        }
-    }
-`;
-        content = content.replace(/(android\s*\{)/, (match) => `${match}${signingConfigsBlock}`);
-      }
-      if (!content.includes("signingConfig signingConfigs.release")) {
-        content = content.replace(
-          /(buildTypes\s*\{[\s\S]*?release\s*\{)/,
-          `$1
-            signingConfig signingConfigs.release`
-        );
-      }
-    } else {
-      await fsx.rm(keystorePath);
-    }
-    await fsx.write(buildGradlePath, content);
-  }
-  /**
-   * Escape single quotes in Groovy string (for use in single-quoted strings)
-   * Groovy: 'string with \'single quote\' inside'
-   */
-  static _escapeGroovyString(value) {
-    return value.replace(/'/g, "\\'");
-  }
-  //#endregion
-  //#region Private - Build
-  /**
-   * Build Android
-   */
-  async _buildAndroid(outPath, buildType) {
-    const androidPath = path.resolve(this._capPath, "android");
-    const targetOutPath = path.resolve(outPath, "android");
-    const isBundle = this._config.platform?.android?.bundle;
-    const gradleTask = buildType === "release" ? isBundle ? "bundleRelease" : "assembleRelease" : "assembleDebug";
-    if (process.platform === "win32") {
-      await this._exec("cmd", ["/c", "gradlew.bat", gradleTask, "--no-daemon"], androidPath);
-    } else {
-      await this._exec("sh", ["./gradlew", gradleTask, "--no-daemon"], androidPath);
-    }
-    await this._copyAndroidBuildOutput(androidPath, targetOutPath, buildType);
-  }
-  /**
-   * Copy Android build output
-   */
-  async _copyAndroidBuildOutput(androidPath, targetOutPath, buildType) {
-    const isBundle = this._config.platform?.android?.bundle;
-    const isSigned = Boolean(this._config.platform?.android?.sign);
-    const ext = isBundle ? "aab" : "apk";
-    const outputType = isBundle ? "bundle" : "apk";
-    const fileName = isSigned ? `app-${buildType}.${ext}` : `app-${buildType}-unsigned.${ext}`;
-    const sourcePath = path.resolve(
-      androidPath,
-      "app/build/outputs",
-      outputType,
-      buildType,
-      fileName
-    );
-    const actualPath = await fsx.exists(sourcePath) ? sourcePath : path.resolve(
-      androidPath,
-      "app/build/outputs",
-      outputType,
-      buildType,
-      `app-${buildType}.${ext}`
-    );
-    if (!await fsx.exists(actualPath)) {
-      Capacitor._logger.warn(`build output not found: ${actualPath}`);
-      return;
-    }
-    const outputFileName = `${this._config.appName}${isSigned ? "" : "-unsigned"}-latest.${ext}`;
-    await fsx.mkdir(targetOutPath);
-    await fsx.copy(actualPath, path.resolve(targetOutPath, outputFileName));
-    const updatesPath = path.resolve(targetOutPath, "updates");
-    await fsx.mkdir(updatesPath);
-    await fsx.copy(actualPath, path.resolve(updatesPath, `${this._npmConfig.version}.${ext}`));
-  }
-  //#endregion
-  //#region Private - Device Execution
-  /**
-   * Update server.url in capacitor.config.ts
-   */
-  async _updateServerUrl(url) {
-    const configPath = path.resolve(this._capPath, "capacitor.config.ts");
-    if (!await fsx.exists(configPath)) return;
-    let content = await fsx.read(configPath);
-    if (content.includes("url:")) {
-      content = content.replace(/url:\s*"[^"]*"/, `url: "${url}"`);
-    } else if (content.includes("server:")) {
-      content = content.replace(/server:\s*\{/, `server: {
-    url: "${url}",`);
-    }
-    await fsx.write(configPath, content);
-  }
-  //#endregion
-  //#region Private - Utilities
-  /**
-   * Convert string to PascalCase
-   */
-  _toPascalCase(str) {
-    return str.replace(/[-_](.)/g, (_, c) => c.toUpperCase()).replace(/^./, (c) => c.toUpperCase());
-  }
-  //#endregion
-}
-export {
-  Capacitor
-};
-//# sourceMappingURL=capacitor.js.map