@simplysm/sd-cli 12.16.13 → 12.16.15

package/src/entry/SdCliCapacitor.ts

@@ -2,18 +2,14 @@ import * as path from "path";
 import { FsUtils, PathUtils, SdLogger, SdProcess } from "@simplysm/sd-core-node";
 import { ISdClientBuilderCapacitorConfig } from "../types/config/ISdProjectConfig";
 import { INpmConfig } from "../types/common-config/INpmConfig";
-import { StringUtils, typescript } from "@simplysm/sd-core-common";
+import { NotImplementError, ObjectUtils, StringUtils, typescript } from "@simplysm/sd-core-common";
 import sharp from "sharp";
 
 export class SdCliCapacitor {
   // 상수 정의
-  private readonly _CAPACITOR_DIR_NAME = ".capacitor";
-  private readonly _CONFIG_FILE_NAME = "capacitor.config.ts";
-  private readonly _KEYSTORE_FILE_NAME = "android.keystore";
-  private readonly _ICON_DIR_NAME = "resources";
+  private readonly _ANDROID_KEYSTORE_FILE_NAME = "android.keystore";
 
-  // private readonly _ANDROID_DIR_NAME = "android";
-  // private readonly _WWW_DIR_NAME = "www";
+  private readonly _capPath: string;
 
   private readonly _platforms: string[];
   private readonly _npmConfig: INpmConfig;
@@ -21,126 +17,83 @@ export class SdCliCapacitor {
   constructor(private readonly _opt: { pkgPath: string; config: ISdClientBuilderCapacitorConfig }) {
     this._platforms = Object.keys(this._opt.config.platform ?? {});
     this._npmConfig = FsUtils.readJson(path.resolve(this._opt.pkgPath, "package.json"));
+    this._capPath = path.resolve(this._opt.pkgPath, ".capacitor");
   }
 
   private static readonly _logger = SdLogger.get(["simplysm", "sd-cli", "SdCliCapacitor"]);
 
-  private static async _execAsync(cmd: string, args: string[], cwd: string): Promise<void> {
+  private static async _execAsync(cmd: string, args: string[], cwd: string): Promise<string> {
     this._logger.debug(`실행 명령: ${cmd + " " + args.join(" ")}`);
-    const msg = await SdProcess.spawnAsync(cmd, args, { cwd });
+    const msg = await SdProcess.spawnAsync(cmd, args, {
+      cwd,
+      env: {
+        FORCE_COLOR: "1", // chalk, supports-color 계열
+        CLICOLOR_FORCE: "1", // 일부 Unix 도구
+        COLORTERM: "truecolor", // 추가 힌트
+      },
+    });
     this._logger.debug(`실행 결과: ${msg}`);
+    return msg;
   }
 
   async initializeAsync(): Promise<void> {
-    const capacitorPath = path.resolve(this._opt.pkgPath, this._CAPACITOR_DIR_NAME);
-
     // 1. Capacitor 프로젝트 초기화
-    const isNewProject = await this._initializeCapacitorProjectAsync(capacitorPath);
+    const changed = await this._initCapAsync();
 
     // 2. Capacitor 설정 파일 생성
-    await this._createCapacitorConfigAsync(capacitorPath);
+    await this._writeCapConfAsync();
 
     // 3. 플랫폼 관리
-    await this._managePlatformsAsync(capacitorPath);
-
-    // 4. 플러그인 관리
-    const pluginsChanged = await this._managePluginsAsync(capacitorPath);
-
-    // 5. 안드로이드 서명 설정
-    await this._setupAndroidSignAsync(capacitorPath);
+    await this._addPlatformsAsync();
 
-    // 6. 아이콘 및 스플래시 스크린 설정
-    await this._setupIconAndSplashScreenAsync(capacitorPath);
+    // 4. 아이콘 설정
+    await this._setupIconAsync();
 
-    // 7. Android 네이티브 설정 (AndroidManifest.xml, build.gradle 등)
+    // 5. Android 네이티브 설정
     if (this._platforms.includes("android")) {
-      await this._configureAndroidNativeAsync(capacitorPath);
+      await this._configureAndroidAsync();
     }
 
-    // 8. 웹 자산 동기화
-    if (isNewProject || pluginsChanged) {
-      await SdCliCapacitor._execAsync("npx", ["cap", "sync"], capacitorPath);
+    // 6. 웹 자산 동기화
+    if (changed) {
+      await SdCliCapacitor._execAsync("npx", ["cap", "sync"], this._capPath);
     } else {
-      await SdCliCapacitor._execAsync("npx", ["cap", "copy"], capacitorPath);
+      await SdCliCapacitor._execAsync("npx", ["cap", "copy"], this._capPath);
     }
   }
 
   // 1. Capacitor 프로젝트 초기화
-  private async _initializeCapacitorProjectAsync(capacitorPath: string): Promise<boolean> {
-    const wwwPath = path.resolve(capacitorPath, "www");
-
-    if (FsUtils.exists(wwwPath)) {
-      SdCliCapacitor._logger.log("이미 생성되어있는 '.capacitor'를 사용합니다.");
-
-      // 버전 동기화
-      const pkgJsonPath = path.resolve(capacitorPath, "package.json");
-
-      if (FsUtils.exists(pkgJsonPath)) {
-        const pkgJson = (await FsUtils.readJsonAsync(pkgJsonPath)) as INpmConfig;
-
-        if (pkgJson.version !== this._npmConfig.version) {
-          pkgJson.version = this._npmConfig.version;
-          await FsUtils.writeJsonAsync(pkgJsonPath, pkgJson, { space: 2 });
-          SdCliCapacitor._logger.debug(`버전 동기화: ${this._npmConfig.version}`);
-        }
-      }
-      return false;
-    }
-
-    // www 폴더 생성
-    await FsUtils.mkdirsAsync(wwwPath);
-
-    // package.json 생성
-    const projNpmConfig = await FsUtils.readJsonAsync(
-      path.resolve(this._opt.pkgPath, "../../package.json"),
-    );
-    const pkgJson = {
-      name: this._opt.config.appId,
-      version: this._npmConfig.version,
-      private: true,
-      volta: projNpmConfig.volta,
-      dependencies: {
-        "@capacitor/core": "^7.0.0",
-        "@capacitor/app": "^7.0.0",
-      },
-      devDependencies: {
-        "@capacitor/cli": "^7.0.0",
-        "@capacitor/assets": "^3.0.0",
-        ...this._platforms.toObject(
-          (item) => `@capacitor/${item}`,
-          () => "^7.0.0",
-        ),
-      },
-    };
-    await FsUtils.writeJsonAsync(path.resolve(capacitorPath, "package.json"), pkgJson, {
-      space: 2,
-    });
+  private async _initCapAsync(): Promise<boolean> {
+    // package.json 파일 구성
+    const depChanged = await this._setupNpmConfAsync();
+    if (!depChanged) return false;
 
     // .yarnrc.yml 작성
     await FsUtils.writeFileAsync(
-      path.resolve(capacitorPath, ".yarnrc.yml"),
+      path.resolve(this._capPath, ".yarnrc.yml"),
       "nodeLinker: node-modules",
     );
 
     // 빈 yarn.lock 작성
-    await FsUtils.writeFileAsync(path.resolve(capacitorPath, "yarn.lock"), "");
+    await FsUtils.writeFileAsync(path.resolve(this._capPath, "yarn.lock"), "");
 
     // yarn install
-    await SdCliCapacitor._execAsync(
-      "yarn",
-      ["dlx", "npm-check-updates", "-u", "--target", "semver"],
-      capacitorPath,
-    );
-    await SdCliCapacitor._execAsync("yarn", ["install"], capacitorPath);
+    const installResult = await SdCliCapacitor._execAsync("yarn", ["install"], this._capPath);
+    const errorLines = installResult.split("\n").filter((item) => item.includes("YN0002"));
+    // peer dependency 경고 감지
+    if (errorLines.length > 0) {
+      throw new Error(errorLines.join("\n"));
+    }
 
-    // capacitor init
+    // cap init
     await SdCliCapacitor._execAsync(
       "npx",
       ["cap", "init", this._opt.config.appName, this._opt.config.appId],
-      capacitorPath,
+      this._capPath,
     );
 
-    // www/index.html 생성
+    // 기본 www/index.html 생성
+    const wwwPath = path.resolve(this._capPath, "www");
     await FsUtils.writeFileAsync(
       path.resolve(wwwPath, "index.html"),
       "<!DOCTYPE html><html><head></head><body></body></html>",
@@ -149,15 +102,111 @@ export class SdCliCapacitor {
     return true;
   }
 
+  private async _setupNpmConfAsync() {
+    const projNpmConfig = await FsUtils.readJsonAsync(
+      path.resolve(this._opt.pkgPath, "../../package.json"),
+    );
+
+    // -----------------------------
+    // 기본설정
+    // -----------------------------
+
+    const capNpmConfPath = path.resolve(this._capPath, "package.json");
+    const orgCapNpmConf = FsUtils.exists(capNpmConfPath)
+      ? await FsUtils.readJsonAsync(path.resolve(this._capPath, "package.json"))
+      : {};
+
+    const capNpmConf = ObjectUtils.clone(orgCapNpmConf);
+    capNpmConf.name = this._opt.config.appId;
+    capNpmConf.version = this._npmConfig.version;
+    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._opt.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];
+        SdCliCapacitor._logger.debug(`플러그인 제거: ${prevPlugin}`);
+      }
+    }
+
+    // 새 플러그인 추가
+    for (const plugin of usePlugins) {
+      if (!(plugin in capNpmConf.dependencies)) {
+        const version = mainDeps[plugin] ?? "*";
+        capNpmConf.dependencies[plugin] = version;
+        SdCliCapacitor._logger.debug(`플러그인 추가: ${plugin}@${version}`);
+      }
+    }
+
+    // -----------------------------
+    // 저장
+    // -----------------------------
+
+    await FsUtils.writeJsonAsync(capNpmConfPath, capNpmConf, { space: 2 });
+
+    return (
+      !ObjectUtils.equal(orgCapNpmConf.volta, capNpmConf.volta) ||
+      !ObjectUtils.equal(orgCapNpmConf.dependencies, capNpmConf.dependencies) ||
+      !ObjectUtils.equal(orgCapNpmConf.devDependencies, capNpmConf.devDependencies)
+    );
+
+    /*// volta, dep, devDep 이 변한 경우에만, yarn install
+    if (
+      !ObjectUtils.equal(orgCapNpmConf.volta, capNpmConf.volta) ||
+      !ObjectUtils.equal(orgCapNpmConf.dependencies, capNpmConf.dependencies) ||
+      !ObjectUtils.equal(orgCapNpmConf.devDependencies, capNpmConf.devDependencies)
+    ) {
+      const installResult = await SdCliCapacitor._execAsync("yarn", ["install"], this._capPath);
+
+      const errorLines = installResult.split("\n").filter((item) => item.includes("YN0002"));
+
+      // peer dependency 경고 감지
+      if (errorLines.length > 0) {
+        throw new Error(errorLines.join("\n"));
+      }
+
+      return true;
+    }
+    // 변경 없으면 아무것도 안 함 → 오프라인 OK
+    return false;*/
+  }
+
   // 2. Capacitor 설정 파일 생성
-  private async _createCapacitorConfigAsync(capacitorPath: string) {
-    const configFilePath = path.resolve(capacitorPath, this._CONFIG_FILE_NAME);
+  private async _writeCapConfAsync() {
+    const confPath = path.resolve(this._capPath, "capacitor.config.ts");
 
     // 플러그인 옵션 생성
     const pluginOptions: Record<string, Record<string, unknown>> = {};
     for (const [pluginName, options] of Object.entries(this._opt.config.plugins ?? {})) {
       if (options !== true) {
-        // @capacitor/splash-screen → SplashScreen 형태로 변환
         const configKey = StringUtils.toPascalCase(pluginName.split("/").last()!);
         pluginOptions[configKey] = options;
       }
@@ -165,7 +214,7 @@ export class SdCliCapacitor {
 
     const pluginsConfigStr =
       Object.keys(pluginOptions).length > 0
-        ? JSON.stringify(pluginOptions, null, 4).replace(/^/gm, "  ").trim()
+        ? JSON.stringify(pluginOptions, null, 2).replace(/^/gm, "  ").trim()
         : "{}";
 
     const configContent = typescript`
@@ -176,203 +225,110 @@ export class SdCliCapacitor {
         appName: "${this._opt.config.appName}",
         server: {
           androidScheme: "http",
-          cleartext: true,
-          allowNavigation: ["*"],
-        },
-        android: {
-          allowMixedContent: true,
-          statusBarOverlaysWebView: false,
+          cleartext: true
         },
+        android: {},
         plugins: ${pluginsConfigStr},
       };
 
       export default config;
     `;
 
-    await FsUtils.writeFileAsync(configFilePath, configContent);
+    await FsUtils.writeFileAsync(confPath, configContent);
   }
 
-  // 3. 플랫폼 관리
-  private async _managePlatformsAsync(capacitorPath: string): Promise<void> {
+  // 3. 플랫폼 추가
+  private async _addPlatformsAsync(): Promise<void> {
     for (const platform of this._platforms) {
-      if (FsUtils.exists(path.resolve(capacitorPath, platform))) continue;
-
-      await SdCliCapacitor._execAsync("npx", ["cap", "add", platform], capacitorPath);
-    }
-  }
-
-  private async _managePluginsAsync(capacitorPath: string): Promise<boolean> {
-    const pkgJsonPath = path.resolve(capacitorPath, "package.json");
-    const pkgJson = (await FsUtils.readJsonAsync(pkgJsonPath)) as INpmConfig;
-
-    const mainDeps = {
-      ...this._npmConfig.dependencies,
-      ...this._npmConfig.devDependencies,
-      ...this._npmConfig.peerDependencies,
-    };
-
-    const usePlugins = Object.keys(this._opt.config.plugins ?? {});
-    const currentDeps = pkgJson.dependencies ?? {};
-
-    let changed = false;
-
-    // 사용하지 않는 플러그인 제거
-    for (const dep of Object.keys(currentDeps)) {
-      if (this._isCapacitorPlugin(dep) && !usePlugins.includes(dep)) {
-        delete currentDeps[dep];
-        changed = true;
-        SdCliCapacitor._logger.debug(`플러그인 제거: ${dep}`);
-      }
-    }
-
-    // 새 플러그인 추가
-    for (const plugin of usePlugins) {
-      if (!(plugin in currentDeps)) {
-        const version = mainDeps[plugin] ?? "^7.0.0";
-        currentDeps[plugin] = version;
-        changed = true;
-        SdCliCapacitor._logger.debug(`플러그인 추가: ${plugin}@${version}`);
-      }
-    }
-
-    // 변경사항 있을 때만 저장 & install
-    if (changed) {
-      pkgJson.dependencies = currentDeps;
-      await FsUtils.writeJsonAsync(pkgJsonPath, pkgJson, { space: 2 });
-      await SdCliCapacitor._execAsync("yarn", ["install"], capacitorPath);
-      return true;
-    }
-    // 변경 없으면 아무것도 안 함 → 오프라인 OK
-    return false;
-  }
-
-  private _isCapacitorPlugin(dep: string): boolean {
-    // 기본 패키지 제외
-    const corePackages = [
-      "@capacitor/core",
-      "@capacitor/android",
-      "@capacitor/ios",
-      "@capacitor/app",
-    ];
-    if (corePackages.includes(dep)) return false;
-
-    return dep.startsWith("@capacitor/") || dep.includes("capacitor-plugin");
-  }
+      if (FsUtils.exists(path.resolve(this._capPath, platform))) continue;
 
-  // 5. 안드로이드 서명 설정
-  private async _setupAndroidSignAsync(capacitorPath: string) {
-    const keystorePath = path.resolve(capacitorPath, this._KEYSTORE_FILE_NAME);
-
-    if (this._opt.config.platform?.android?.sign) {
-      await FsUtils.copyAsync(
-        path.resolve(this._opt.pkgPath, this._opt.config.platform.android.sign.keystore),
-        keystorePath,
-      );
-    } else {
-      await FsUtils.removeAsync(keystorePath);
+      await SdCliCapacitor._execAsync("npx", ["cap", "add", platform], this._capPath);
     }
   }
 
-  private async _setupIconAndSplashScreenAsync(capacitorPath: string): Promise<void> {
-    const resourcesDirPath = path.resolve(capacitorPath, this._ICON_DIR_NAME);
+  // 4. 아이콘 설정
+  private async _setupIconAsync(): Promise<void> {
+    const assetsDirPath = path.resolve(this._capPath, "assets");
 
     if (this._opt.config.icon != null) {
-      await FsUtils.mkdirsAsync(resourcesDirPath);
+      await FsUtils.mkdirsAsync(assetsDirPath);
 
       const iconSource = path.resolve(this._opt.pkgPath, this._opt.config.icon);
 
-      // 아이콘만 생성
-      const logoPath = path.resolve(resourcesDirPath, "logo.png");
-      await this._createCenteredImageAsync(iconSource, logoPath, 1024, 0.6);
-
-      await this._cleanupExistingIconsAsync(capacitorPath);
-
-      try {
-        await SdCliCapacitor._execAsync(
-          "npx",
-          [
-            "@capacitor/assets",
-            "generate",
-            "--android",
-            "--iconBackgroundColor",
-            "#ffffff",
-            "--splashBackgroundColor",
-            "#ffffff",
-          ],
-          capacitorPath,
-        );
-      } catch (e) {
-        SdCliCapacitor._logger.warn("아이콘 생성 실패, 기본 아이콘 사용", e);
-      }
+      // 아이콘 생성
+      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._cleanupExistingIconsAsync();
+
+      await SdCliCapacitor._execAsync(
+        "npx",
+        [
+          "@capacitor/assets",
+          "generate",
+          "--iconBackgroundColor",
+          "#ffffff",
+          "--splashBackgroundColor",
+          "#ffffff",
+        ],
+        this._capPath,
+      );
     } else {
-      await FsUtils.removeAsync(resourcesDirPath);
+      await FsUtils.removeAsync(assetsDirPath);
     }
   }
 
-  // 중앙에 로고를 배치한 이미지 생성
-  private async _createCenteredImageAsync(
-    sourcePath: string,
-    outputPath: string,
-    outputSize: number,
-    logoRatio: number, // 0.0 ~ 1.0
-  ): Promise<void> {
-    const logoSize = Math.floor(outputSize * logoRatio);
-    const padding = Math.floor((outputSize - logoSize) / 2);
-
-    await sharp(sourcePath)
-      .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(outputPath);
-  }
-
   // 기존 아이콘 파일 삭제
-  private async _cleanupExistingIconsAsync(capacitorPath: string): Promise<void> {
-    const androidResPath = path.resolve(capacitorPath, "android/app/src/main/res");
-
-    if (!FsUtils.exists(androidResPath)) return;
-
-    // mipmap 폴더의 모든 ic_launcher 관련 파일 삭제 (png + xml)
-    const mipmapDirs = await FsUtils.globAsync(path.resolve(androidResPath, "mipmap-*"));
-    for (const dir of mipmapDirs) {
-      const iconFiles = await FsUtils.globAsync(path.resolve(dir, "ic_launcher*")); // 확장자 제거
-      for (const file of iconFiles) {
-        await FsUtils.removeAsync(file);
-      }
-    }
-
-    // drawable 폴더의 splash/icon 관련 파일도 삭제
-    const drawableDirs = await FsUtils.globAsync(path.resolve(androidResPath, "drawable*"));
-    for (const dir of drawableDirs) {
-      const splashFiles = await FsUtils.globAsync(path.resolve(dir, "splash*"));
-      const iconFiles = await FsUtils.globAsync(path.resolve(dir, "ic_launcher*"));
-      for (const file of [...splashFiles, ...iconFiles]) {
-        await FsUtils.removeAsync(file);
-      }
-    }
-  }
-
-  // 7. Android 네이티브 설정
-  private async _configureAndroidNativeAsync(capacitorPath: string) {
-    const androidPath = path.resolve(capacitorPath, "android");
-
-    if (!FsUtils.exists(androidPath)) {
-      return;
-    }
-
-    // JAVA_HOME 찾기
-    await this._configureAndroidGradlePropertiesAsync(androidPath);
-
-    // local.properties 생성
-    await this._configureSdkPathAsync(androidPath);
+  // private async _cleanupExistingIconsAsync(): Promise<void> {
+  //   const androidResPath = path.resolve(capacitorPath, "android/app/src/main/res");
+  //
+  //   if (!FsUtils.exists(androidResPath)) return;
+  //
+  //   // mipmap 폴더의 모든 ic_launcher 관련 파일 삭제 (png + xml)
+  //   const mipmapDirs = await FsUtils.globAsync(path.resolve(androidResPath, "mipmap-*"));
+  //   for (const dir of mipmapDirs) {
+  //     const iconFiles = await FsUtils.globAsync(path.resolve(dir, "ic_launcher*")); // 확장자 제거
+  //     for (const file of iconFiles) {
+  //       await FsUtils.removeAsync(file);
+  //     }
+  //   }
+  //
+  //   // drawable 폴더의 splash/icon 관련 파일도 삭제
+  //   const drawableDirs = await FsUtils.globAsync(path.resolve(androidResPath, "drawable*"));
+  //   for (const dir of drawableDirs) {
+  //     const splashFiles = await FsUtils.globAsync(path.resolve(dir, "splash*"));
+  //     const iconFiles = await FsUtils.globAsync(path.resolve(dir, "ic_launcher*"));
+  //     for (const file of [...splashFiles, ...iconFiles]) {
+  //       await FsUtils.removeAsync(file);
+  //     }
+  //   }
+  // }
+
+  // 5. Android 네이티브 설정
+  private async _configureAndroidAsync() {
+    const androidPath = path.resolve(this._capPath, "android");
+
+    // JAVA_HOME 경로 설정
+    await this._configureAndroidJavaHomePathAsync(androidPath);
+
+    // SDK 경로 설정
+    await this._configureAndroidSdkPathAsync(androidPath);
 
     // AndroidManifest.xml 수정
     await this._configureAndroidManifestAsync(androidPath);
@@ -380,67 +336,28 @@ export class SdCliCapacitor {
     // build.gradle 수정 (필요시)
     await this._configureAndroidBuildGradleAsync(androidPath);
 
-    // strings.xml 앱 이름 수정
-    await this._configureAndroidStringsAsync(androidPath);
-
-    // styles.xml 수정
-    await this._configureAndroidStylesAsync(androidPath);
-  }
-
-  private async _configureAndroidStylesAsync(androidPath: string) {
-    const stylesPath = path.resolve(androidPath, "app/src/main/res/values/styles.xml");
-
-    if (!FsUtils.exists(stylesPath)) {
-      return;
-    }
-
-    let stylesContent = await FsUtils.readFileAsync(stylesPath);
-
-    // Edge-to-Edge 비활성화만
-    if (!stylesContent.includes("android:windowOptOutEdgeToEdgeEnforcement")) {
-      stylesContent = stylesContent.replace(
-        /(<style[^>]*name="AppTheme"[^>]*>)/,
-        `$1\n        <item name="android:windowOptOutEdgeToEdgeEnforcement">true</item>`,
-      );
-    }
-
-    // NoActionBarLaunch를 단순 NoActionBar로
-    stylesContent = stylesContent.replace(
-      /(<style\s+name="AppTheme\.NoActionBarLaunch"\s+parent=")[^"]+(")/,
-      `$1Theme.AppCompat.Light.NoActionBar$2`,
-    );
+    // TODO: strings.xml 앱 이름 수정?? WHY?
+    // await this._configureAndroidStringsAsync(androidPath);
 
-    // splash 관련 전부 제거
-    stylesContent = stylesContent.replace(
-      /\s*<item name="android:background">@drawable\/splash<\/item>/g,
-      "",
-    );
-    stylesContent = stylesContent.replace(
-      /\s*<item name="android:windowSplashScreen[^"]*">[^<]*<\/item>/g,
-      "",
-    );
-
-    await FsUtils.writeFileAsync(stylesPath, stylesContent);
+    // TODO: styles.xml 수정?? WHY?
+    // await this._configureAndroidStylesAsync(androidPath);
   }
 
-  private async _configureAndroidGradlePropertiesAsync(androidPath: string) {
+  // JAVA_HOME 경로 설정
+  private async _configureAndroidJavaHomePathAsync(androidPath: string) {
     const gradlePropsPath = path.resolve(androidPath, "gradle.properties");
 
-    if (!FsUtils.exists(gradlePropsPath)) {
-      return;
-    }
-
     let content = await FsUtils.readFileAsync(gradlePropsPath);
 
     // Java 21 경로 자동 탐색
-    const java21Path = this._findJava21();
+    const java21Path = await this._findJava21Async();
     if (java21Path != null && !content.includes("org.gradle.java.home")) {
       content += `\norg.gradle.java.home=${java21Path.replace(/\\/g, "\\\\")}\n`;
       FsUtils.writeFile(gradlePropsPath, content);
     }
   }
 
-  private _findJava21(): string | undefined {
+  private async _findJava21Async(): Promise<string | undefined> {
     const patterns = [
       "C:/Program Files/Amazon Corretto/jdk21*",
       "C:/Program Files/Eclipse Adoptium/jdk-21*",
@@ -449,7 +366,7 @@ export class SdCliCapacitor {
     ];
 
     for (const pattern of patterns) {
-      const matches = FsUtils.glob(pattern);
+      const matches = await FsUtils.globAsync(pattern);
       if (matches.length > 0) {
         // 가장 최신 버전 선택 (정렬 후 마지막)
         return matches.sort().at(-1);
@@ -459,14 +376,10 @@ export class SdCliCapacitor {
     return undefined;
   }
 
-  private async _configureSdkPathAsync(androidPath: string) {
-    // local.properties 생성
+  // SDK 경로 설정
+  private async _configureAndroidSdkPathAsync(androidPath: string) {
     const localPropsPath = path.resolve(androidPath, "local.properties");
 
-    if (FsUtils.exists(localPropsPath)) {
-      return;
-    }
-
     // SDK 경로 탐색 (Cordova 방식과 유사)
     const sdkPath = this._findAndroidSdk();
     if (sdkPath != null) {
@@ -474,13 +387,34 @@ export class SdCliCapacitor {
     }
   }
 
-  private async _configureAndroidManifestAsync(androidPath: string) {
-    const manifestPath = path.resolve(androidPath, "app/src/main/AndroidManifest.xml");
+  private _findAndroidSdk(): string | undefined {
+    // 1. 환경변수 확인
+    const fromEnv = process.env["ANDROID_HOME"] ?? process.env["ANDROID_SDK_ROOT"];
+    if (fromEnv != null && FsUtils.exists(fromEnv)) {
+      return fromEnv;
+    }
 
-    if (!FsUtils.exists(manifestPath)) {
-      return;
+    // 2. 일반적인 설치 경로 탐색
+    const candidates = [
+      path.resolve(process.env["LOCALAPPDATA"] ?? "", "Android/Sdk"),
+      path.resolve(process.env["HOME"] ?? "", "Android/Sdk"),
+      "C:/Program Files/Android/Sdk",
+      "C:/Android/Sdk",
+    ];
+
+    for (const candidate of candidates) {
+      if (FsUtils.exists(candidate)) {
+        return candidate;
+      }
     }
 
+    return undefined;
+  }
+
+  // AndroidManifest.xml 수정
+  private async _configureAndroidManifestAsync(androidPath: string) {
+    const manifestPath = path.resolve(androidPath, "app/src/main/AndroidManifest.xml");
+
     let manifestContent = await FsUtils.readFileAsync(manifestPath);
 
     // usesCleartextTraffic 설정
@@ -547,13 +481,10 @@ export class SdCliCapacitor {
     await FsUtils.writeFileAsync(manifestPath, manifestContent);
   }
 
+  // build.gradle 수정 (필요시)
   private async _configureAndroidBuildGradleAsync(androidPath: string) {
     const buildGradlePath = path.resolve(androidPath, "app/build.gradle");
 
-    if (!FsUtils.exists(buildGradlePath)) {
-      return;
-    }
-
     let gradleContent = await FsUtils.readFileAsync(buildGradlePath);
 
     // versionName, versionCode 설정
@@ -570,17 +501,31 @@ export class SdCliCapacitor {
     // SDK 버전 설정
     if (this._opt.config.platform?.android?.sdkVersion != null) {
       const sdkVersion = this._opt.config.platform.android.sdkVersion;
-      gradleContent = gradleContent.replace(/minSdkVersion \d+/, `minSdkVersion ${sdkVersion}`);
+      gradleContent = gradleContent.replace(/minSdkVersion .+/, `minSdkVersion ${sdkVersion}`);
       gradleContent = gradleContent.replace(
-        /targetSdkVersion \d+/,
+        /targetSdkVersion .+/,
         `targetSdkVersion ${sdkVersion}`,
       );
+    } else {
+      gradleContent = gradleContent.replace(
+        /minSdkVersion .+/,
+        `minSdkVersion rootProject.ext.minSdkVersion`,
+      );
+      gradleContent = gradleContent.replace(
+        /targetSdkVersion .+/,
+        `targetSdkVersion rootProject.ext.targetSdkVersion`,
+      );
     }
 
     // Signing 설정
+    const keystorePath = path.resolve(this._capPath, this._ANDROID_KEYSTORE_FILE_NAME);
     const signConfig = this._opt.config.platform?.android?.sign;
     if (signConfig) {
-      const keystoreRelativePath = `../../${this._KEYSTORE_FILE_NAME}`;
+      await FsUtils.copyAsync(path.resolve(this._opt.pkgPath, signConfig.keystore), keystorePath);
+
+      const keystoreRelativePath = path
+        .relative(path.dirname(buildGradlePath), keystorePath)
+        .replace(/\\/g, "/");
       const keystoreType = signConfig.keystoreType ?? "jks";
 
       // signingConfigs 블록 추가
@@ -610,12 +555,15 @@ export class SdCliCapacitor {
           `$1\n            signingConfig signingConfigs.release`,
         );
       }
+    } else {
+      //TODO: gradleContent에서 signingConfigs 관련 부분 삭제
+      await FsUtils.removeAsync(keystorePath);
     }
 
     await FsUtils.writeFileAsync(buildGradlePath, gradleContent);
   }
 
-  private async _configureAndroidStringsAsync(androidPath: string) {
+  /*private async _configureAndroidStringsAsync(androidPath: string) {
     const stringsPath = path.resolve(androidPath, "app/src/main/res/values/strings.xml");
 
     if (!FsUtils.exists(stringsPath)) {
@@ -641,31 +589,64 @@ export class SdCliCapacitor {
     );
 
     await FsUtils.writeFileAsync(stringsPath, stringsContent);
-  }
+  }*/
+
+  /*private async _configureAndroidStylesAsync(androidPath: string) {
+    const stylesPath = path.resolve(androidPath, "app/src/main/res/values/styles.xml");
+
+    if (!FsUtils.exists(stylesPath)) {
+      return;
+    }
+
+    let stylesContent = await FsUtils.readFileAsync(stylesPath);
+
+    // Edge-to-Edge 비활성화만
+    if (!stylesContent.includes("android:windowOptOutEdgeToEdgeEnforcement")) {
+      stylesContent = stylesContent.replace(
+        /(<style[^>]*name="AppTheme"[^>]*>)/,
+        `$1\n        <item name="android:windowOptOutEdgeToEdgeEnforcement">true</item>`,
+      );
+    }
+
+    // NoActionBarLaunch를 단순 NoActionBar로
+    stylesContent = stylesContent.replace(
+      /(<style\s+name="AppTheme\.NoActionBarLaunch"\s+parent=")[^"]+(")/,
+      `$1Theme.AppCompat.Light.NoActionBar$2`,
+    );
+
+    // splash 관련 전부 제거
+    stylesContent = stylesContent.replace(
+      /\s*<item name="android:background">@drawable\/splash<\/item>/g,
+      "",
+    );
+    stylesContent = stylesContent.replace(
+      /\s*<item name="android:windowSplashScreen[^"]*">[^<]*<\/item>/g,
+      "",
+    );
+
+    await FsUtils.writeFileAsync(stylesPath, stylesContent);
+  }*/
 
   async buildAsync(outPath: string): Promise<void> {
-    const capacitorPath = path.resolve(this._opt.pkgPath, this._CAPACITOR_DIR_NAME);
     const buildType = this._opt.config.debug ? "debug" : "release";
 
     // 플랫폼별 빌드
     await Promise.all(
       this._platforms.map(async (platform) => {
         // 해당 플랫폼만 copy
-        await SdCliCapacitor._execAsync("npx", ["cap", "copy", platform], capacitorPath);
+        await SdCliCapacitor._execAsync("npx", ["cap", "copy", platform], this._capPath);
 
         if (platform === "android") {
-          await this._buildAndroidAsync(capacitorPath, outPath, buildType);
+          await this._buildAndroidAsync(outPath, buildType);
+        } else {
+          throw new NotImplementError();
         }
       }),
     );
   }
 
-  private async _buildAndroidAsync(
-    capacitorPath: string,
-    outPath: string,
-    buildType: string,
-  ): Promise<void> {
-    const androidPath = path.resolve(capacitorPath, "android");
+  private async _buildAndroidAsync(outPath: string, buildType: string): Promise<void> {
+    const androidPath = path.resolve(this._capPath, "android");
     const targetOutPath = path.resolve(outPath, "android");
 
     const isBundle = this._opt.config.platform?.android?.bundle;
@@ -731,30 +712,6 @@ export class SdCliCapacitor {
     );
   }
 
-  private _findAndroidSdk(): string | undefined {
-    // 1. 환경변수 확인
-    const fromEnv = process.env["ANDROID_HOME"] ?? process.env["ANDROID_SDK_ROOT"];
-    if (fromEnv != null && FsUtils.exists(fromEnv)) {
-      return fromEnv;
-    }
-
-    // 2. 일반적인 설치 경로 탐색
-    const candidates = [
-      path.resolve(process.env["LOCALAPPDATA"] ?? "", "Android/Sdk"),
-      path.resolve(process.env["HOME"] ?? "", "Android/Sdk"),
-      "C:/Program Files/Android/Sdk",
-      "C:/Android/Sdk",
-    ];
-
-    for (const candidate of candidates) {
-      if (FsUtils.exists(candidate)) {
-        return candidate;
-      }
-    }
-
-    return undefined;
-  }
-
   static async runWebviewOnDeviceAsync(opt: {
     platform: string;
     package: string;
@@ -798,7 +755,7 @@ export class SdCliCapacitor {
     try {
       await this._execAsync("npx", ["cap", "run", opt.platform], capacitorPath);
     } catch (err) {
-      await SdProcess.spawnAsync("adb", ["kill-server"]);
+      await this._execAsync("adb", ["kill-server"], capacitorPath);
       throw err;
     }
   }