@simplysm/sd-cli 14.0.30 → 14.0.32

package/src/angular/vite-angular-plugin.ts

@@ -1,23 +1,18 @@
-import type { Plugin, ModuleNode, ViteDevServer } from "vite";
-import type { IncomingMessage, ServerResponse } from "http";
+import type { Plugin } from "vite";
 import { JavaScriptTransformer } from "@angular/build/private";
-import { createHash } from "crypto";
-import fsp from "fs/promises";
-import fs from "fs";
 import os from "os";
 import path from "path";
 import ts from "typescript";
 import { consola } from "consola";
 import { pathx } from "@simplysm/core-node";
-import { AngularSourceFileCache } from "../utils/angular-compiler.js";
+import { AngularSourceFileCache } from "./angular-compiler.js";
 import { getPackageSourceFiles } from "../utils/tsconfig.js";
 import {
   AngularBuildPipeline,
   type PipelineDiagnosticResult,
-} from "../utils/angular-build-pipeline.js";
+} from "./angular-build-pipeline.js";
 import { loadSdConfig } from "../utils/sd-config.js";
-import type { SdConfig, SdPackageConfig } from "../sd-config.types.js";
-import { resolveReplaceDepEntries } from "../utils/replace-deps.js";
+import type { SdPackageConfig } from "../sd-config.types.js";
 
 const logger = consola.withTag("sd:cli:angular");
 
@@ -25,46 +20,30 @@ const logger = consola.withTag("sd:cli:angular");
 export interface SdAngularPluginOptions {
   /** sd.config.ts packages 키 (패키지 디렉토리명) */
   pkg: string;
-  /** rebuild 시작 콜백 (CLI 상태 보고용) */
-  onBuildStart?: () => void;
-  /** rebuild 완료 콜백 (CLI 상태 보고용) */
-  onBuild?: (result: {
-    success: boolean;
-    errors?: string[];
-    warnings?: string[];
-  }) => void;
 }
 
 /**
- * Angular AOT 컴파일을 수행하는 Vite 플러그인.
+ * Angular AOT 컴파일을 수행하는 Vite 플러그인 (Vitest 전용).
  *
  * AngularBuildPipeline + JavaScriptTransformer를 관리한다.
+ * - watchChange: 변경 파일 수집 (Vitest watch 모드용)
  * - buildStart: Pipeline 초기화 + 컴파일 + emit
  * - transform: .ts 파일에 대해 컴파일된 JS 반환 + JavaScriptTransformer 적용
- * - handleHotUpdate: incremental rebuild + HMR
  * - buildEnd: 리소스 정리
  */
 export function sdAngularPlugin(options: SdAngularPluginOptions): Plugin {
   let pipeline: AngularBuildPipeline | undefined;
   let sourceFileCache: AngularSourceFileCache | undefined;
   let jsTransformer: JavaScriptTransformer | undefined;
-  let prebundleTransformer: JavaScriptTransformer | undefined;
 
-  const templateUpdates = new Map<string, string>();
-  let hmrLock: Promise<void> = Promise.resolve();
-  let devServer: ViteDevServer | undefined;
-
-  /** Rolldown watch 모드에서 변경된 파일 경로를 수집한다. buildStart 재호출 시 캐시 무효화에 사용. */
+  /** Vitest watch 모드에서 변경된 파일 경로를 수집한다. buildStart 재호출 시 캐시 무효화에 사용. */
   const pendingWatchChanges = new Set<string>();
 
-  // sd.config.ts에서 로딩된 설정 (config() 훅에서 초기화)
+  // config() 훅에서 초기화
   let isDev = false;
-  let enableSourcemap = false;
-  let isDevServer = false;
-  let sdConfig: SdConfig | undefined;
+  let enableSourcemap = true;
   let pkgConfig: SdPackageConfig | undefined;
   let resolvedPkgDir: string | undefined;
-  let replaceDepDistPaths: string[] | undefined;
 
   function createJsTransformer(): JavaScriptTransformer {
     const maxThreads = Math.max(1, Math.floor((os.cpus().length * 2) / 3));
@@ -79,48 +58,6 @@ export function sdAngularPlugin(options: SdAngularPluginOptions): Plugin {
     );
   }
 
-  /**
-   * sd.config.ts의 replaceDeps glob에서 node_modules 패키지의 dist 경로를 계산한다.
-   */
-  function resolveReplaceDeps(pkgDir: string, config: SdConfig): string[] | undefined {
-    if (config.replaceDeps == null) return undefined;
-
-    // node_modules 하위 패키지명 수집
-    const nodeModulesDir = path.join(pkgDir, "node_modules");
-    const targetNames: string[] = [];
-    try {
-      for (const entry of fs.readdirSync(nodeModulesDir)) {
-        if (entry.startsWith(".")) continue;
-        if (entry.startsWith("@")) {
-          // scoped package
-          const scopeDir = path.join(nodeModulesDir, entry);
-          for (const subEntry of fs.readdirSync(scopeDir)) {
-            targetNames.push(`${entry}/${subEntry}`);
-          }
-        } else {
-          targetNames.push(entry);
-        }
-      }
-    } catch {
-      // node_modules 없으면 빈 배열
-      return undefined;
-    }
-
-    const matched = resolveReplaceDepEntries(config.replaceDeps, targetNames);
-    if (matched.length === 0) return undefined;
-
-    const distPaths: string[] = [];
-    for (const dep of matched) {
-      const distDir = path.join(nodeModulesDir, ...dep.targetName.split("/"), "dist");
-      try {
-        distPaths.push(pathx.posix(fs.realpathSync(distDir)));
-      } catch {
-        distPaths.push(pathx.posix(distDir));
-      }
-    }
-    return distPaths;
-  }
-
   return {
     name: "sd-angular",
     enforce: "pre",
@@ -134,7 +71,7 @@ export function sdAngularPlugin(options: SdAngularPluginOptions): Plugin {
       isDev = env.mode === "development";
 
       // sd.config.ts 로딩
-      sdConfig = await loadSdConfig({ cwd, dev: isDev, opt: [] });
+      const sdConfig = await loadSdConfig({ cwd, dev: isDev, opt: [] });
       const rawPkgConfig = sdConfig.packages[options.pkg];
       if (rawPkgConfig == null) {
         throw new Error(`sd.config.ts에 패키지 "${options.pkg}"가 정의되어 있지 않습니다.`);
@@ -143,94 +80,10 @@ export function sdAngularPlugin(options: SdAngularPluginOptions): Plugin {
 
       // 패키지 디렉토리 resolve
       resolvedPkgDir = path.resolve(cwd, "packages", options.pkg);
-
-      // browserSupport (client 패키지에만 존재)
-      const browserSupport = pkgConfig.target === "client"
-        ? (pkgConfig).browserSupport
-        : undefined;
-
-      // legacyModule
-      const legacyModule = browserSupport?.legacyModule === true;
-
-      // replaceDepDistPaths 계산
-      replaceDepDistPaths = resolveReplaceDeps(resolvedPkgDir, sdConfig);
-
-      // Linker 캐시 디렉토리 (기본값)
-      // enableSourcemap은 아직 확정되지 않으므로 isDev로 임시 결정
-      const linkerCacheDir = path.join(cwd, ".cache", "linker", isDev ? "sm" : "nosm");
-
-      return {
-        define: {
-          ngDevMode: isDev ? undefined : "false",
-          ngJitMode: "false",
-          ngHmrMode: isDev && !legacyModule ? undefined : "false",
-        },
-        optimizeDeps: {
-          esbuildOptions: {
-            plugins: [
-              {
-                name: "angular-vite-optimize-deps",
-                setup(build: { onLoad: Function }) {
-                  build.onLoad(
-                    { filter: /\.[cm]?js$/ },
-                    async (args: { path: string }) => {
-                      if (!/\.[cm]?js$/.test(args.path)) return null;
-
-                      // replaceDeps 파일은 Linker 캐시를 건너뛴다 (항상 fresh 처리)
-                      if (
-                        replaceDepDistPaths != null &&
-                        replaceDepDistPaths.some((p) =>
-                          pathx.posix(args.path).startsWith(p),
-                        )
-                      ) {
-                        return null;
-                      }
-
-                      if (prebundleTransformer == null) return null;
-
-                      const content = await fsp.readFile(args.path, "utf-8");
-                      const hash = createHash("sha256").update(content).digest("hex");
-                      const cachePath = path.join(linkerCacheDir, `${hash}.js`);
-
-                      try {
-                        const cached = await fsp.readFile(cachePath, "utf-8");
-                        return { contents: cached, loader: "js" as const };
-                      } catch {
-                        // cache miss
-                      }
-
-                      const result = await prebundleTransformer.transformFile(args.path);
-                      const resultStr =
-                        typeof result === "string"
-                          ? result
-                          : new TextDecoder().decode(result);
-
-                      try {
-                        await fsp.mkdir(linkerCacheDir, { recursive: true });
-                        await fsp.writeFile(cachePath, resultStr);
-                      } catch {
-                        // cache write failure — non-fatal
-                      }
-
-                      return { contents: resultStr, loader: "js" as const };
-                    },
-                  );
-                },
-              },
-            ],
-          },
-        },
-      };
     },
 
     configResolved(resolved: { build: { sourcemap: unknown } }) {
       enableSourcemap = resolved.build.sourcemap !== false || isDev;
-
-      // Transformer 생성 (sourcemap 확정 후)
-      prebundleTransformer = new JavaScriptTransformer(
-        { sourcemap: enableSourcemap, jit: false, thirdPartySourcemaps: enableSourcemap },
-        1,
-      );
     },
 
     async buildStart() {
@@ -248,7 +101,7 @@ export function sdAngularPlugin(options: SdAngularPluginOptions): Plugin {
       // AngularSourceFileCache 생성 (또는 재사용)
       sourceFileCache ??= new AngularSourceFileCache();
 
-      // Rolldown watch 재빌드: 변경된 파일의 캐시 무효화
+      // Vitest watch 재빌드: 변경된 파일의 캐시 무효화
       let hadPendingChanges = false;
       if (pendingWatchChanges.size > 0) {
         hadPendingChanges = true;
@@ -257,11 +110,10 @@ export function sdAngularPlugin(options: SdAngularPluginOptions): Plugin {
         pendingWatchChanges.clear();
       }
 
-      // legacyModule, postCssPlugins from sd.config.ts (client 패키지에만 존재)
+      // postCssPlugins from sd.config.ts (client 패키지에만 존재)
       const browserSupport = pkgConfig?.target === "client"
         ? (pkgConfig).browserSupport
         : undefined;
-      const legacyModule = browserSupport?.legacyModule === true;
       const postCssPlugins = browserSupport?.postCss?.plugins;
 
       // Pipeline 생성 (최초) 또는 재사용
@@ -275,7 +127,6 @@ export function sdAngularPlugin(options: SdAngularPluginOptions): Plugin {
           | Record<string, unknown>
           | undefined,
         sourceFileCache,
-        enableHmr: isDevServer && !legacyModule,
         compilerOptionsTransformer: (opts) => ({
           ...opts,
           noEmit: false,
@@ -298,14 +149,6 @@ export function sdAngularPlugin(options: SdAngularPluginOptions): Plugin {
       }
       const pipelineResult = await pipeline.initialize();
 
-      // templateUpdates 수집
-      templateUpdates.clear();
-      if (pipelineResult.templateUpdates != null) {
-        for (const [key, value] of pipelineResult.templateUpdates) {
-          templateUpdates.set(key, value);
-        }
-      }
-
       // 진단 보고
       reportDiagnostics(pipelineResult.diagnostics);
 
@@ -313,144 +156,27 @@ export function sdAngularPlugin(options: SdAngularPluginOptions): Plugin {
       for (const err of pipelineResult.scssErrors) {
         logger.error(err);
       }
-
-      // 초기 빌드 결과 보고 (dev, prod 공통)
-      options.onBuild?.({
-        success: pipelineResult.diagnostics.errors.length === 0,
-        errors: pipelineResult.diagnostics.errors.map((e) => e.message),
-        warnings: pipelineResult.diagnostics.warnings.map((w) => w.message),
-      });
-    },
-
-    async handleHotUpdate({
-      file,
-      modules,
-      server,
-    }: {
-      file: string;
-      modules: ModuleNode[];
-      server: ViteDevServer;
-      timestamp: number;
-      read: () => string | Promise<string>;
-    }): Promise<ModuleNode[] | void> {
-      if (pipeline == null || !isDev) return;
-      if (
-        !file.endsWith(".ts") &&
-        !file.endsWith(".html") &&
-        !file.endsWith(".scss")
-      ) {
-        // replaceDeps .js 파일 변경 시 full-reload 강제
-        if (
-          file.endsWith(".js") &&
-          devServer != null &&
-          replaceDepDistPaths != null &&
-          replaceDepDistPaths.some((p) =>
-            pathx.posix(file).startsWith(p),
-          )
-        ) {
-          devServer.hot.send({ type: "full-reload" });
-          return [];
-        }
-        return;
-      }
-
-      const normalizedFile = pathx.posix(file);
-      let filesToUpdate: string[];
-
-      if (file.endsWith(".scss")) {
-        // SCSS @use 의존성 역방향 탐색: 변경된 SCSS를 @use하는 파일을 찾아 재컴파일
-        const affectedOwnerFiles = pipeline.findAffectedByScss(normalizedFile);
-        if (affectedOwnerFiles.length === 0) return;
-        filesToUpdate = affectedOwnerFiles;
-      } else {
-        // 의존성 필터: TypeScript program에 포함되지 않은 파일은 건너뜀
-        const programFiles = pipeline.getTsProgram().getSourceFiles();
-        const isInProgram = programFiles.some(
-          (sf) => pathx.posix(sf.fileName) === normalizedFile,
-        );
-        if (!isInProgram) {
-          logger.debug(`변경된 파일이 빌드에 포함되지 않아 리빌드 건너뜀: ${normalizedFile}`);
-          return;
-        }
-        filesToUpdate = [file];
-      }
-
-      // 경쟁 조건 방지: 이전 HMR 처리 완료 대기
-      const prevLock = hmrLock;
-      let releaseLock!: () => void;
-      hmrLock = new Promise<void>((resolve) => {
-        releaseLock = resolve;
-      });
-      await prevLock;
-
-      options.onBuildStart?.();
-
-      try {
-        // rebuild 시작 시 이전 templateUpdates 정리
-        templateUpdates.clear();
-
-        const pipelineResult = await pipeline.update(filesToUpdate);
-
-        // templateUpdates 수집
-        if (pipelineResult.templateUpdates != null) {
-          for (const [key, value] of pipelineResult.templateUpdates) {
-            templateUpdates.set(key, value);
-          }
-        }
-
-        // Pipeline.update() 후 실제 re-emit된 소스 경로 수집
-        const affectedPaths = pipeline.getLatestEmittedSourcePaths();
-
-        reportDiagnostics(pipelineResult.diagnostics);
-
-        options.onBuild?.({
-          success: pipelineResult.diagnostics.errors.length === 0,
-          errors: pipelineResult.diagnostics.errors.map((e) => e.message),
-          warnings: pipelineResult.diagnostics.warnings.map((w) => w.message),
-        });
-
-        if (file.endsWith(".scss")) {
-          // SCSS: moduleGraph에서 영향받은 TS 모듈 조회
-          const result: ModuleNode[] = [];
-          for (const p of affectedPaths) {
-            const mods = server.moduleGraph.getModulesByFile(p);
-            if (mods) result.push(...mods);
-          }
-          return result;
-        } else {
-          // TS/HTML: 전달받은 modules에서 영향받은 모듈 필터
-          const affectedSet = new Set(affectedPaths);
-          return modules.filter(
-            (m) => m.file != null && affectedSet.has(pathx.posix(m.file)),
-          );
-        }
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        logger.error(`HMR recompile failed: ${message}`);
-        options.onBuild?.({ success: false, errors: [message] });
-        return;
-      } finally {
-        releaseLock();
-      }
     },
 
     async transform(_code, id) {
       if (jsTransformer == null) return;
 
+      // query param 제거
+      const cleanId = id.split("?")[0];
       let code = _code;
 
       // Phase 1: TS 컴파일 — .ts 파일은 Pipeline이 emit한 JS로 교체
-      if (id.endsWith(".ts")) {
-        const normalizedId = pathx.posix(id);
+      if (cleanId.endsWith(".ts")) {
+        const normalizedId = pathx.posix(cleanId);
         const emittedContent = pipeline?.getEmittedFile(normalizedId);
         if (emittedContent == null) return;
         code = emittedContent;
-      } else if (!id.endsWith(".mjs") && !id.endsWith(".js")) {
+      } else if (!cleanId.endsWith(".mjs") && !cleanId.endsWith(".js")) {
         return;
       }
 
       // Phase 2: JS 변환 — Angular Linker로 partial → full AOT 링킹 + 최적화
-      const transformed = await jsTransformer.transformData(pathx.posix(id), code, false);
+      const transformed = await jsTransformer.transformData(pathx.posix(cleanId), code, false);
       const transformedCode = new TextDecoder().decode(transformed);
 
       // 인라인 소스맵 분리 (Rollup 경고 방지)
@@ -468,71 +194,12 @@ export function sdAngularPlugin(options: SdAngularPluginOptions): Plugin {
     },
 
     async buildEnd() {
-      // dev 모드에서는 pipeline/jsTransformer를 유지 (HMR용 incremental compilation)
-      if (!isDev) {
-        if (jsTransformer != null) {
-          await jsTransformer.close();
-          jsTransformer = undefined;
-        }
-        if (prebundleTransformer != null) {
-          await prebundleTransformer.close();
-        }
-        pipeline = undefined;
+      if (jsTransformer != null) {
+        await jsTransformer.close();
+        jsTransformer = undefined;
       }
+      pipeline = undefined;
     },
-
-    configureServer(server: ViteDevServer) {
-      devServer = server;
-      isDevServer = true;
-
-      // component-middleware 등록 (HMR template updates 서빙)
-      server.middlewares.use(angularComponentMiddleware(templateUpdates, server.config.base));
-
-      // dev server 종료 시 리소스 정리
-      server.httpServer?.on("close", () => {
-        void Promise.all([
-          jsTransformer?.close(),
-          prebundleTransformer?.close(),
-        ])
-          .catch((err: unknown) => {
-            logger.error(
-              `Resource dispose failed: ${err instanceof Error ? err.message : String(err)}`,
-            );
-          })
-          .finally(() => {
-            jsTransformer = undefined;
-            pipeline = undefined;
-          });
-      });
-    },
-  };
-}
-
-function angularComponentMiddleware(
-  templateUpdates: Map<string, string>,
-  basePath: string,
-): (req: IncomingMessage, res: ServerResponse, next: () => void) => void {
-  return (req, res, next) => {
-    const rawUrl = req.url ?? "";
-    const parsedUrl = new URL(rawUrl, "http://localhost");
-    const pathname = decodeURIComponent(parsedUrl.pathname);
-    const strippedPathname =
-      basePath !== "/" && pathname.startsWith(basePath)
-        ? pathname.slice(basePath.length - 1)
-        : pathname;
-    if (!strippedPathname.includes("/@ng/component")) {
-      next();
-      return;
-    }
-
-    const componentId = parsedUrl.searchParams.get("c") ?? "";
-    const body = templateUpdates.get(encodeURIComponent(componentId)) ?? "";
-
-    res.writeHead(200, {
-      "Content-Type": "text/javascript",
-      "Cache-Control": "no-cache",
-    });
-    res.end(body);
   };
 }
 

package/src/capacitor/capacitor-build.ts

@@ -0,0 +1,142 @@
+import { cpx, fsx, pathx } from "@simplysm/core-node";
+import { consola, LogLevels } from "consola";
+import type { SdCapacitorSignConfig } from "../sd-config.types.js";
+
+const _logger = consola.withTag("sd:cli:capacitor");
+
+/**
+ * 서명 설정을 build.gradle에 추가하고 keystore 파일을 복사
+ */
+export async function configureSigningConfig(
+  pkgPath: string,
+  androidPath: string,
+  sign: SdCapacitorSignConfig,
+): Promise<void> {
+  // keystore 파일 확인 및 복사
+  const keystoreSrc = pathx.posixResolve(pkgPath, sign.keystore);
+  if (!(await fsx.exists(keystoreSrc))) {
+    throw new Error(`keystore 파일을 찾을 수 없습니다: ${keystoreSrc}`);
+  }
+
+  const keystoreDest = pathx.posixResolve(androidPath, "app", "android.keystore");
+  await fsx.copy(keystoreSrc, keystoreDest);
+
+  // build.gradle에 signingConfigs 추가
+  const buildGradlePath = pathx.posixResolve(androidPath, "app/build.gradle");
+  let content = await fsx.read(buildGradlePath);
+
+  // 이미 signingConfigs가 있으면 스킵
+  if (content.includes("signingConfigs")) return;
+
+  const storeType = sign.keystoreType ?? "jks";
+  const escapeGroovy = (s: string) => s.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+  const escapedStorePassword = escapeGroovy(sign.storePassword);
+  const escapedKeyPassword = escapeGroovy(sign.password);
+
+  const signingBlock = `    signingConfigs {
+        release {
+            storeFile file("android.keystore")
+            storePassword '${escapedStorePassword}'
+            keyAlias '${sign.alias}'
+            keyPassword '${escapedKeyPassword}'
+            storeType "${storeType}"
+        }
+    }
+`;
+
+  // signingConfigs 블록을 buildTypes 앞에 삽입
+  content = content.replace(/(\s*buildTypes\s*\{)/, (match) => `\n${signingBlock}${match}`);
+
+  // buildTypes.release에 signingConfig 추가
+  content = content.replace(
+    /(buildTypes\s*\{[\s\S]*?release\s*\{)/,
+    "$1\n            signingConfig signingConfigs.release",
+  );
+
+  await fsx.write(buildGradlePath, content);
+}
+
+/**
+ * Gradle 빌드 실행 (cross-platform)
+ */
+export async function buildAndroid(
+  capPath: string,
+  buildType: string,
+  isBundle: boolean,
+): Promise<void> {
+  let gradleTask: string;
+  if (buildType === "debug") {
+    gradleTask = "assembleDebug";
+  } else if (isBundle) {
+    gradleTask = "bundleRelease";
+  } else {
+    gradleTask = "assembleRelease";
+  }
+
+  const androidPath = pathx.posixResolve(capPath, "android");
+  const isWindows = process.platform === "win32";
+  const isDebug = consola.level >= LogLevels.debug;
+
+  if (isWindows) {
+    _logger.debug(`Gradle 실행: cmd /c gradlew.bat ${gradleTask}`);
+    const { stdout } = await cpx.spawn("cmd", ["/c", "gradlew.bat", gradleTask, "--no-daemon"], {
+      cwd: androidPath,
+      ...(isDebug ? { stdio: ["ignore", "inherit", "inherit"] } : {}),
+    });
+    _logger.debug(`실행 결과: ${stdout}`);
+  } else {
+    const gradlew = pathx.posixResolve(androidPath, "gradlew");
+    _logger.debug(`Gradle 실행: ${gradlew} ${gradleTask}`);
+    const { stdout } = await cpx.spawn(gradlew, [gradleTask, "--no-daemon"], {
+      cwd: androidPath,
+      ...(isDebug ? { stdio: ["ignore", "inherit", "inherit"] } : {}),
+    });
+    _logger.debug(`실행 결과: ${stdout}`);
+  }
+}
+
+/**
+ * 빌드 산출물을 출력 경로에 복사
+ */
+export async function copyBuildOutput(
+  capPath: string,
+  outPath: string,
+  buildType: string,
+  isBundle: boolean,
+  appName: string,
+  version: string,
+): Promise<void> {
+  const ext = isBundle ? "aab" : "apk";
+  const outputType = isBundle ? "bundle" : "apk";
+  const androidBuildPath = pathx.posixResolve(
+    capPath,
+    "android/app/build/outputs",
+    outputType,
+    buildType,
+  );
+
+  // 빌드 산출물 찾기
+  _logger.debug(`빌드 산출물 탐색: ${androidBuildPath}`);
+  const candidates = await fsx.glob(pathx.posixResolve(androidBuildPath, `app-*.${ext}`));
+  if (candidates.length === 0) {
+    throw new Error(`빌드 산출물을 찾을 수 없습니다: ${androidBuildPath}`);
+  }
+  const builtFile = candidates[0];
+  _logger.debug(`빌드 산출물: ${builtFile}`);
+  const isUnsigned = builtFile.includes("unsigned");
+
+  // 출력 디렉토리 생성
+  const androidOutPath = pathx.posixResolve(outPath, "android");
+  const updatesPath = pathx.posixResolve(androidOutPath, "updates");
+  await fsx.mkdir(androidOutPath);
+  await fsx.mkdir(updatesPath);
+
+  // latest 파일명 결정
+  const unsignedSuffix = isUnsigned ? "-unsigned" : "";
+  const latestName = `${appName}${unsignedSuffix}-latest.${ext}`;
+  const versionedName = `${version}.${ext}`;
+
+  // 복사
+  await fsx.copy(builtFile, pathx.posixResolve(androidOutPath, latestName));
+  await fsx.copy(builtFile, pathx.posixResolve(updatesPath, versionedName));
+}