@simplysm/sd-cli 12.15.68 → 12.15.69

package/dist/entry/SdCliCapacitor.d.ts

@@ -0,0 +1,37 @@
+import { ISdClientBuilderCapacitorConfig } from "../types/config/ISdProjectConfig";
+export declare class SdCliCapacitor {
+    private readonly _opt;
+    private readonly _CAPACITOR_DIR_NAME;
+    private readonly _CONFIG_FILE_NAME;
+    private readonly _KEYSTORE_FILE_NAME;
+    private readonly _ICON_DIR_PATH;
+    private readonly _platforms;
+    private readonly _npmConfig;
+    constructor(_opt: {
+        pkgPath: string;
+        config: ISdClientBuilderCapacitorConfig;
+    });
+    private static readonly _logger;
+    private static _execAsync;
+    initializeAsync(): Promise<void>;
+    private _initializeCapacitorProjectAsync;
+    private _syncVersion;
+    private _createCapacitorConfig;
+    private _managePlatformsAsync;
+    private _managePluginsAsync;
+    private _setupAndroidSign;
+    private _setupIconAndSplashScreenAsync;
+    private _configureAndroidNative;
+    private _configureAndroidManifest;
+    private _configureAndroidBuildGradle;
+    private _configureAndroidStrings;
+    buildAsync(outPath: string): Promise<void>;
+    private _buildPlatformAsync;
+    private _buildAndroidAsync;
+    private _copyAndroidBuildOutput;
+    static runWebviewOnDeviceAsync(opt: {
+        platform: string;
+        package: string;
+        url?: string;
+    }): Promise<void>;
+}

package/dist/entry/SdCliCapacitor.js

@@ -0,0 +1,390 @@
+import * as path from "path";
+import { FsUtils, PathUtils, SdLogger, SdProcess } from "@simplysm/sd-core-node";
+import { StringUtils, typescript } from "@simplysm/sd-core-common";
+export class SdCliCapacitor {
+    constructor(_opt) {
+        this._opt = _opt;
+        // 상수 정의
+        this._CAPACITOR_DIR_NAME = ".capacitor";
+        this._CONFIG_FILE_NAME = "capacitor.config.ts";
+        this._KEYSTORE_FILE_NAME = "android.keystore";
+        this._ICON_DIR_PATH = "resources";
+        this._platforms = Object.keys(this._opt.config.platform ?? { android: {} });
+        this._npmConfig = FsUtils.readJson(path.resolve(this._opt.pkgPath, "package.json"));
+    }
+    static { this._logger = SdLogger.get(["simplysm", "sd-cli", "SdCliCapacitor"]); }
+    static async _execAsync(cmd, args, cwd) {
+        this._logger.debug(`실행 명령: ${cmd + " " + args.join(" ")}`);
+        const msg = await SdProcess.spawnAsync(cmd, args, { cwd });
+        this._logger.debug(`실행 결과: ${msg}`);
+    }
+    async initializeAsync() {
+        const capacitorPath = path.resolve(this._opt.pkgPath, this._CAPACITOR_DIR_NAME);
+        // 1. Capacitor 프로젝트 초기화
+        await this._initializeCapacitorProjectAsync(capacitorPath);
+        // 2. Capacitor 설정 파일 생성
+        this._createCapacitorConfig(capacitorPath);
+        // 3. 플랫폼 관리
+        await this._managePlatformsAsync(capacitorPath);
+        // 4. 플러그인 관리
+        await this._managePluginsAsync(capacitorPath);
+        // 5. 안드로이드 서명 설정
+        this._setupAndroidSign(capacitorPath);
+        // 6. 아이콘 및 스플래시 스크린 설정
+        await this._setupIconAndSplashScreenAsync(capacitorPath);
+        // 7. Android 네이티브 설정 (AndroidManifest.xml, build.gradle 등)
+        if (this._platforms.includes("android")) {
+            this._configureAndroidNative(capacitorPath);
+        }
+        // 8. 웹 자산 동기화
+        await SdCliCapacitor._execAsync("npx", ["cap", "sync"], capacitorPath);
+    }
+    // 1. Capacitor 프로젝트 초기화
+    async _initializeCapacitorProjectAsync(capacitorPath) {
+        if (FsUtils.exists(capacitorPath)) {
+            SdCliCapacitor._logger.log("이미 생성되어있는 '.capacitor'를 사용합니다.");
+            // 버전 동기화
+            this._syncVersion(capacitorPath);
+        }
+        else {
+            FsUtils.mkdirs(capacitorPath);
+            // package.json 생성
+            const pkgJson = {
+                name: this._opt.config.appId,
+                version: this._npmConfig.version,
+                private: true,
+                dependencies: {
+                    "@capacitor/core": "^7.0.0",
+                },
+                devDependencies: {
+                    "@capacitor/cli": "^7.0.0",
+                    "@capacitor/assets": "^3.0.0",
+                },
+            };
+            FsUtils.writeJson(path.resolve(capacitorPath, "package.json"), pkgJson, { space: 2 });
+            // yarn install
+            await SdCliCapacitor._execAsync("yarn", ["install"], capacitorPath);
+            // capacitor init
+            await SdCliCapacitor._execAsync("npx", ["cap", "init", this._opt.config.appName, this._opt.config.appId], capacitorPath);
+        }
+    }
+    // 버전 동기화
+    _syncVersion(capacitorPath) {
+        const pkgJsonPath = path.resolve(capacitorPath, "package.json");
+        if (FsUtils.exists(pkgJsonPath)) {
+            const pkgJson = FsUtils.readJson(pkgJsonPath);
+            if (pkgJson.version !== this._npmConfig.version) {
+                pkgJson.version = this._npmConfig.version;
+                FsUtils.writeJson(pkgJsonPath, pkgJson, { space: 2 });
+                SdCliCapacitor._logger.log(`버전 동기화: ${this._npmConfig.version}`);
+            }
+        }
+    }
+    // 2. Capacitor 설정 파일 생성
+    _createCapacitorConfig(capacitorPath) {
+        const configFilePath = path.resolve(capacitorPath, this._CONFIG_FILE_NAME);
+        // 플러그인 옵션 생성
+        const pluginOptions = {};
+        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;
+            }
+        }
+        const pluginsConfigStr = Object.keys(pluginOptions).length > 0
+            ? JSON.stringify(pluginOptions, null, 4).replace(/^/gm, "  ").trim()
+            : "{}";
+        const configContent = typescript `
+      import type { CapacitorConfig } from "@capacitor/cli";
+
+      const config: CapacitorConfig = {
+        appId: "${this._opt.config.appId}",
+        appName: "${this._opt.config.appName}",
+        server: {
+          androidScheme: "http",
+          cleartext: true,
+          allowNavigation: ["*"],
+        },
+        android: {
+          allowMixedContent: true,
+        },
+        plugins: ${pluginsConfigStr},
+      };
+
+      export default config;
+    `;
+        FsUtils.writeFile(configFilePath, configContent);
+    }
+    // 3. 플랫폼 관리
+    async _managePlatformsAsync(capacitorPath) {
+        for (const platform of this._platforms) {
+            if (FsUtils.exists(path.resolve(capacitorPath, platform)))
+                continue;
+            await SdCliCapacitor._execAsync("npx", ["cap", "add", platform], capacitorPath);
+        }
+    }
+    // 4. 플러그인 관리
+    async _managePluginsAsync(capacitorPath) {
+        const pkgJsonPath = path.resolve(capacitorPath, "package.json");
+        const pkgJson = FsUtils.readJson(pkgJsonPath);
+        const currentDeps = Object.keys(pkgJson.dependencies ?? {});
+        const usePlugins = Object.keys(this._opt.config.plugins ?? {});
+        // 사용하지 않는 플러그인 제거
+        for (const dep of currentDeps) {
+            // @capacitor/core, @capacitor/android 등 기본 패키지는 제외
+            if (dep.startsWith("@capacitor/") &&
+                ["core", "android", "ios"].some((p) => dep.endsWith(p))) {
+                continue;
+            }
+            // 플러그인 목록에 없는 패키지는 제거
+            if (!usePlugins.includes(dep)) {
+                // Capacitor 관련 플러그인만 제거
+                if (dep.startsWith("@capacitor/") || dep.includes("capacitor-plugin")) {
+                    try {
+                        await SdCliCapacitor._execAsync("yarn", ["remove", dep], capacitorPath);
+                        SdCliCapacitor._logger.log(`플러그인 제거: ${dep}`);
+                    }
+                    catch {
+                        SdCliCapacitor._logger.warn(`플러그인 제거 실패: ${dep}`);
+                    }
+                }
+            }
+        }
+        // 새 플러그인 설치
+        for (const plugin of usePlugins) {
+            if (!currentDeps.includes(plugin)) {
+                try {
+                    await SdCliCapacitor._execAsync("yarn", ["add", plugin], capacitorPath);
+                    SdCliCapacitor._logger.log(`플러그인 설치: ${plugin}`);
+                }
+                catch {
+                    SdCliCapacitor._logger.warn(`플러그인 설치 실패: ${plugin}`);
+                }
+            }
+        }
+    }
+    // 5. 안드로이드 서명 설정
+    _setupAndroidSign(capacitorPath) {
+        const keystorePath = path.resolve(capacitorPath, this._KEYSTORE_FILE_NAME);
+        if (this._opt.config.platform?.android?.sign) {
+            FsUtils.copy(path.resolve(this._opt.pkgPath, this._opt.config.platform.android.sign.keystore), keystorePath);
+        }
+        else {
+            FsUtils.remove(keystorePath);
+        }
+    }
+    // 6. 아이콘 및 스플래시 스크린 설정
+    async _setupIconAndSplashScreenAsync(capacitorPath) {
+        const iconDirPath = path.resolve(capacitorPath, this._ICON_DIR_PATH);
+        // ICON 파일 복사
+        if (this._opt.config.icon != null) {
+            FsUtils.mkdirs(iconDirPath);
+            const iconSource = path.resolve(this._opt.pkgPath, this._opt.config.icon);
+            // icon.png, splash.png 둘 다 같은 파일 사용
+            FsUtils.copy(iconSource, path.resolve(iconDirPath, "icon.png"));
+            FsUtils.copy(iconSource, path.resolve(iconDirPath, "splash.png"));
+            // @capacitor/assets로 아이콘/스플래시 리사이징
+            try {
+                await SdCliCapacitor._execAsync("npx", ["@capacitor/assets", "generate", "--android"], capacitorPath);
+            }
+            catch {
+                SdCliCapacitor._logger.warn("아이콘 리사이징 실패, 기본 아이콘 사용");
+            }
+        }
+        else {
+            FsUtils.remove(iconDirPath);
+        }
+    }
+    // 7. Android 네이티브 설정
+    _configureAndroidNative(capacitorPath) {
+        const androidPath = path.resolve(capacitorPath, "android");
+        if (!FsUtils.exists(androidPath)) {
+            return;
+        }
+        // AndroidManifest.xml 수정
+        this._configureAndroidManifest(androidPath);
+        // build.gradle 수정 (필요시)
+        this._configureAndroidBuildGradle(androidPath);
+        // strings.xml 앱 이름 수정
+        this._configureAndroidStrings(androidPath);
+    }
+    _configureAndroidManifest(androidPath) {
+        const manifestPath = path.resolve(androidPath, "app/src/main/AndroidManifest.xml");
+        if (!FsUtils.exists(manifestPath)) {
+            return;
+        }
+        let manifestContent = FsUtils.readFile(manifestPath);
+        // usesCleartextTraffic 설정
+        if (!manifestContent.includes("android:usesCleartextTraffic")) {
+            manifestContent = manifestContent.replace("<application", '<application android:usesCleartextTraffic="true"');
+        }
+        // 추가 권한 설정
+        const permissions = this._opt.config.platform?.android?.permissions ?? [];
+        for (const perm of permissions) {
+            const permTag = `<uses-permission android:name="android.permission.${perm.name}"`;
+            if (!manifestContent.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} />\n`;
+                // tools 네임스페이스 추가
+                if (perm.ignore != null && !manifestContent.includes("xmlns:tools=")) {
+                    manifestContent = manifestContent.replace("<manifest xmlns:android", '<manifest xmlns:tools="http://schemas.android.com/tools" xmlns:android');
+                }
+                manifestContent = manifestContent.replace("</manifest>", `${permLine}</manifest>`);
+            }
+        }
+        // 추가 application 설정
+        const appConfig = this._opt.config.platform?.android?.config;
+        if (appConfig) {
+            for (const [key, value] of Object.entries(appConfig)) {
+                const attr = `android:${key}="${value}"`;
+                if (!manifestContent.includes(`android:${key}=`)) {
+                    manifestContent = manifestContent.replace("<application", `<application ${attr}`);
+                }
+            }
+        }
+        FsUtils.writeFile(manifestPath, manifestContent);
+    }
+    _configureAndroidBuildGradle(androidPath) {
+        const buildGradlePath = path.resolve(androidPath, "app/build.gradle");
+        if (!FsUtils.exists(buildGradlePath)) {
+            return;
+        }
+        let gradleContent = FsUtils.readFile(buildGradlePath);
+        // versionName, versionCode 설정
+        const version = this._npmConfig.version;
+        const versionParts = version.split(".");
+        const versionCode = parseInt(versionParts[0] ?? "0") * 10000 +
+            parseInt(versionParts[1] ?? "0") * 100 +
+            parseInt(versionParts[2] ?? "0");
+        gradleContent = gradleContent.replace(/versionCode \d+/, `versionCode ${versionCode}`);
+        gradleContent = gradleContent.replace(/versionName "[^"]+"/, `versionName "${version}"`);
+        // 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(/targetSdkVersion \d+/, `targetSdkVersion ${sdkVersion}`);
+        }
+        // Signing 설정
+        const signConfig = this._opt.config.platform?.android?.sign;
+        if (signConfig) {
+            const keystoreRelativePath = `../${this._KEYSTORE_FILE_NAME}`;
+            const keystoreType = signConfig.keystoreType ?? "jks";
+            // signingConfigs 블록 추가
+            if (!gradleContent.includes("signingConfigs")) {
+                const signingConfigsBlock = `
+    signingConfigs {
+        release {
+            storeFile file("${keystoreRelativePath}")
+            storePassword "${signConfig.storePassword}"
+            keyAlias "${signConfig.alias}"
+            keyPassword "${signConfig.password}"
+            storeType "${keystoreType}"
+        }
+    }
+`;
+                // android { 블록 내부에 추가
+                gradleContent = gradleContent.replace(/(android\s*\{)/, `$1${signingConfigsBlock}`);
+            }
+            // buildTypes.release에 signingConfig 추가
+            if (!gradleContent.includes("signingConfig signingConfigs.release")) {
+                gradleContent = gradleContent.replace(/(buildTypes\s*\{[\s\S]*?release\s*\{)/, `$1\n            signingConfig signingConfigs.release`);
+            }
+        }
+        FsUtils.writeFile(buildGradlePath, gradleContent);
+    }
+    _configureAndroidStrings(androidPath) {
+        const stringsPath = path.resolve(androidPath, "app/src/main/res/values/strings.xml");
+        if (!FsUtils.exists(stringsPath)) {
+            return;
+        }
+        let stringsContent = FsUtils.readFile(stringsPath);
+        stringsContent = stringsContent.replace(/<string name="app_name">[^<]+<\/string>/, `<string name="app_name">${this._opt.config.appName}</string>`);
+        stringsContent = stringsContent.replace(/<string name="title_activity_main">[^<]+<\/string>/, `<string name="title_activity_main">${this._opt.config.appName}</string>`);
+        stringsContent = stringsContent.replace(/<string name="package_name">[^<]+<\/string>/, `<string name="package_name">${this._opt.config.appId}</string>`);
+        stringsContent = stringsContent.replace(/<string name="custom_url_scheme">[^<]+<\/string>/, `<string name="custom_url_scheme">${this._opt.config.appId}</string>`);
+        FsUtils.writeFile(stringsPath, stringsContent);
+    }
+    async buildAsync(outPath) {
+        const capacitorPath = path.resolve(this._opt.pkgPath, this._CAPACITOR_DIR_NAME);
+        const buildType = this._opt.config.debug ? "debug" : "release";
+        // 웹 자산 동기화
+        await SdCliCapacitor._execAsync("npx", ["cap", "sync"], capacitorPath);
+        // 플랫폼별 빌드
+        await Promise.all(this._platforms.map((platform) => this._buildPlatformAsync(capacitorPath, outPath, platform, buildType)));
+    }
+    async _buildPlatformAsync(capacitorPath, outPath, platform, buildType) {
+        if (platform === "android") {
+            await this._buildAndroidAsync(capacitorPath, outPath, buildType);
+        }
+        // iOS 지원 시 추가
+    }
+    async _buildAndroidAsync(capacitorPath, outPath, buildType) {
+        const androidPath = path.resolve(capacitorPath, "android");
+        const targetOutPath = path.resolve(outPath, "android");
+        // Gradle wrapper로 빌드
+        const isBundle = this._opt.config.platform?.android?.bundle;
+        const gradleTask = buildType === "release" ? (isBundle ? "bundleRelease" : "assembleRelease") : "assembleDebug";
+        // gradlew 실행 권한 부여 (Linux/Mac)
+        const gradlewPath = path.resolve(androidPath, "gradlew");
+        if (FsUtils.exists(gradlewPath)) {
+            try {
+                await SdCliCapacitor._execAsync("chmod", ["+x", "gradlew"], androidPath);
+            }
+            catch {
+                // Windows에서는 무시
+            }
+        }
+        // Gradle 빌드 실행
+        const gradleCmd = process.platform === "win32" ? "gradlew.bat" : "./gradlew";
+        await SdCliCapacitor._execAsync(gradleCmd, [gradleTask, "--no-daemon"], androidPath);
+        // 빌드 결과물 복사
+        this._copyAndroidBuildOutput(androidPath, targetOutPath, buildType);
+    }
+    _copyAndroidBuildOutput(androidPath, targetOutPath, buildType) {
+        const isBundle = this._opt.config.platform?.android?.bundle;
+        const isSigned = !!this._opt.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 = FsUtils.exists(sourcePath)
+            ? sourcePath
+            : path.resolve(androidPath, "app/build/outputs", outputType, buildType, `app-${buildType}.${ext}`);
+        if (!FsUtils.exists(actualPath)) {
+            SdCliCapacitor._logger.warn(`빌드 결과물을 찾을 수 없습니다: ${actualPath}`);
+            return;
+        }
+        const outputFileName = `${this._opt.config.appName}${isSigned ? "" : "-unsigned"}-latest.${ext}`;
+        FsUtils.mkdirs(targetOutPath);
+        FsUtils.copy(actualPath, path.resolve(targetOutPath, outputFileName));
+        const updatesPath = path.resolve(targetOutPath, "updates");
+        FsUtils.mkdirs(updatesPath);
+        FsUtils.copy(actualPath, path.resolve(updatesPath, `${this._npmConfig.version}.${ext}`));
+    }
+    static async runWebviewOnDeviceAsync(opt) {
+        const projNpmConf = FsUtils.readJson(path.resolve(process.cwd(), "package.json"));
+        const allPkgPaths = projNpmConf.workspaces.mapMany((item) => FsUtils.glob(PathUtils.posix(process.cwd(), item)));
+        const capacitorPath = path.resolve(allPkgPaths.single((item) => item.endsWith(opt.package)), ".capacitor");
+        if (opt.url !== undefined) {
+            // capacitor.config.ts의 server.url 설정 업데이트
+            const configPath = path.resolve(capacitorPath, "capacitor.config.ts");
+            if (FsUtils.exists(configPath)) {
+                let configContent = FsUtils.readFile(configPath);
+                const serverUrl = `${opt.url.replace(/\/$/, "")}/${opt.package}/capacitor/`;
+                // 기존 url 설정이 있으면 교체, 없으면 server 블록 첫 줄에 추가
+                if (configContent.includes("url:")) {
+                    configContent = configContent.replace(/url:\s*"[^"]*"/, `url: "${serverUrl}"`);
+                }
+                else if (configContent.includes("server:")) {
+                    configContent = configContent.replace(/server:\s*\{/, `server: {\n    url: "${serverUrl}",`);
+                }
+                FsUtils.writeFile(configPath, configContent);
+            }
+        }
+        // cap sync 후 run
+        await this._execAsync("npx", ["cap", "sync", opt.platform], capacitorPath);
+        await this._execAsync("npx", ["cap", "run", opt.platform, "--target", "device"], capacitorPath);
+    }
+}

package/dist/pkg-builders/client/SdClientBuildRunner.d.ts

@@ -5,5 +5,6 @@ export declare class SdClientBuildRunner extends SdBuildRunnerBase<"client"> {
     protected _logger: SdLogger;
     private _ngBundlers?;
     private _cordova?;
+    private _capacitor?;
     protected _runAsync(modifiedFileSet?: Set<TNormPath>): Promise<ISdBuildResult>;
 }

package/dist/pkg-builders/client/SdClientBuildRunner.js

@@ -5,6 +5,7 @@ import { SdNgBundler } from "./SdNgBundler";
 import { SdCliCordova } from "../../entry/SdCliCordova";
 import { SdCliNgRoutesFileGenerator } from "./SdCliNgRoutesFileGenerator";
 import { SdCliElectron } from "../../entry/SdCliElectron";
+import { SdCliCapacitor } from "../../entry/SdCliCapacitor";
 export class SdClientBuildRunner extends SdBuildRunnerBase {
     constructor() {
         super(...arguments);
@@ -27,6 +28,15 @@ export class SdClientBuildRunner extends SdBuildRunnerBase {
                     });
                     await this._cordova.initializeAsync();
                 }
+                // capacitor
+                if (this._pkgConf.builder?.capacitor) {
+                    this._debug("Preparing Capacitor...");
+                    this._capacitor = new SdCliCapacitor({
+                        pkgPath: this._opt.pkgPath,
+                        config: this._pkgConf.builder.capacitor,
+                    });
+                    await this._capacitor.initializeAsync();
+                }
                 // routes
                 const npmConf = (await FsUtils.readJsonAsync(path.resolve(this._opt.pkgPath, "package.json")));
                 if ("@angular/router" in (npmConf.dependencies ?? {})) {
@@ -80,6 +90,10 @@ export class SdClientBuildRunner extends SdBuildRunnerBase {
                 this._debug("Building Cordova...");
                 await this._cordova.buildAsync(path.resolve(this._opt.pkgPath, "dist"));
             }
+            if (!this._opt.watch?.dev && this._capacitor) {
+                this._debug("Building Capacitor...");
+                await this._capacitor.buildAsync(path.resolve(this._opt.pkgPath, "dist"));
+            }
             if (!this._opt.watch?.dev && this._pkgConf.builder?.electron) {
                 this._debug("Bulding Electron...");
                 await SdCliElectron.buildAsync({

package/dist/pkg-builders/client/SdNgBundler.js

@@ -54,7 +54,9 @@ export class SdNgBundler {
                     ? PathUtils.norm(this._opt.pkgPath, ".electron/src")
                     : this._conf.builderType === "cordova" && !this._opt.watch?.dev
                         ? PathUtils.norm(this._opt.pkgPath, ".cordova/www")
-                        : PathUtils.norm(this._opt.pkgPath, "dist", this._conf.builderType);
+                        : this._conf.builderType === "capacitor" && !this._opt.watch?.dev
+                            ? PathUtils.norm(this._opt.pkgPath, ".capacitor/www")
+                            : PathUtils.norm(this._opt.pkgPath, "dist", this._conf.builderType);
     }
     markForChanges(filePaths) {
         for (const filePath of filePaths) {

package/dist/sd-cli-entry.js

@@ -10,12 +10,7 @@ import { SdCliElectron } from "./entry/SdCliElectron";
 import { SdCliLocalUpdate } from "./entry/SdCliLocalUpdate";
 import { SdCliPostInstall } from "./entry/SdCliPostInstall";
 import { SdCliProject } from "./entry/SdCliProject";
-import convertPrivateToHash from "./fix/convertPrivateToHash";
-import removeSdAngularSymbolNames from "./fix/removeSdAngularSymbolNames";
-import convertSdAngularSymbolNames from "./fix/convertSdAngularSymbolNames";
-import { removeUnusedInjects } from "./fix/removeUnusedInjects";
-import removeUnusedProtectedReadonly from "./fix/removeUnusedProtectedReadonly";
-import { removeUnusedImports } from "./fix/removeUnusedImports";
+import { SdCliCapacitor } from "./entry/SdCliCapacitor";
 Error.stackTraceLimit = Infinity;
 EventEmitter.defaultMaxListeners = 0;
 await yargs(hideBin(process.argv))
@@ -199,48 +194,27 @@ await yargs(hideBin(process.argv))
     describe: "Webview로 오픈할 URL",
     demandOption: true,
 }), async (argv) => await SdCliCordova.runWebviewOnDeviceAsync(argv))
-    .command("commit", "AI를 통해 변경사항에 대한 커밋 메시지를 작성하여, 커밋 및 푸쉬를 수행합니다.", (cmd) => cmd.version(false).hide("help").hide("debug"), async () => await SdCliAiCommand.commitAsync())
-    .command("postinstall", "설치후 자동실행할 작업", (cmd) => cmd.version(false).hide("help").hide("debug"), () => SdCliPostInstall.run())
-    .command("fix", "가능한 내용 자동 수정", (cmd) => cmd
+    .command("run-capacitor <platform> <package> [url]", "변경감지중인 플랫폼을 Capacitor 디바이스에 앱 형태로 띄웁니다.", (cmd) => cmd
     .version(false)
     .hide("help")
     .hide("debug")
-    .options({
-    library: {
-        type: "boolean",
-        describe: "simplysm 라이브러리 픽스",
-        default: false,
-    },
-}), (argv) => {
-    // GIT 사용중일 경우, 커밋되지 않은 수정사항이 있는지 확인
-    /*if (FsUtils.exists(path.resolve(process.cwd(), ".git"))) {
-      const gitStatusResult = await SdProcess.spawnAsync("git status");
-      if (gitStatusResult.includes("Changes") || gitStatusResult.includes("Untracked")) {
-        throw new Error("커밋되지 않은 정보가 있습니다. FIX오류시 롤백이 불가능하므로, 미리 커밋을 해놔야 합니다.\n" + gitStatusResult);
-      }
-    }*/
-    convertPrivateToHash();
-    //-- 심볼정리
-    removeSdAngularSymbolNames();
-    convertSdAngularSymbolNames();
-    //-- inject/import 정리
-    removeUnusedInjects();
-    removeUnusedProtectedReadonly();
-    removeUnusedImports();
-    if (argv.library)
-        return;
-    // convertSdSheetBindingsSafely();
-    // convertSetupCumulateSelectedKeysToObjectParam();
-    // convertExtendsSdModalBaseToInterface();
-    // convertModalShowParams();
-    // convertExtendsSdPrintTemplateBaseToInterface();
-    // convertPrintParams();
-    // convertToUsePermsSignal();
-    // convertGetMenusToUsableMenus();
-    // convertFlatPagesToUsableFlatMenus();
-    // convertSdIconToFaIcon();
-    // convertSelectModalButtonToSelectButton();
+    .positional("platform", {
+    type: "string",
+    describe: "빌드 플랫폼(android,...)",
+    demandOption: true,
 })
+    .positional("package", {
+    type: "string",
+    describe: "패키지명",
+    demandOption: true,
+})
+    .positional("url", {
+    type: "string",
+    describe: "Webview로 오픈할 URL",
+    demandOption: true,
+}), async (argv) => await SdCliCapacitor.runWebviewOnDeviceAsync(argv))
+    .command("commit", "AI를 통해 변경사항에 대한 커밋 메시지를 작성하여, 커밋 및 푸쉬를 수행합니다.", (cmd) => cmd.version(false).hide("help").hide("debug"), async () => await SdCliAiCommand.commitAsync())
+    .command("postinstall", "설치후 자동실행할 작업", (cmd) => cmd.version(false).hide("help").hide("debug"), () => SdCliPostInstall.run())
     .strict()
     .recommendCommands()
     .fail((msg, err, cmd) => {

package/dist/types/config/ISdProjectConfig.d.ts

@@ -45,6 +45,8 @@ export interface ISdClientPackageConfig {
     builder?: {
         web?: ISdClientBuilderWebConfig;
         electron?: ISdClientBuilderElectronConfig;
+        capacitor?: ISdClientBuilderCapacitorConfig;
+        /** @deprecated */
         cordova?: ISdClientBuilderCordovaConfig;
     };
 }
@@ -72,6 +74,7 @@ export interface ISdClientBuilderElectronConfig {
 export interface ISdClientBuilderWebConfig {
     env?: Record<string, string>;
 }
+/** @deprecated */
 export interface ISdClientBuilderCordovaConfig {
     appId: string;
     appName: string;
@@ -101,6 +104,34 @@ export interface ISdClientBuilderCordovaConfig {
     env?: Record<string, string>;
     browserslist?: string[];
 }
+export interface ISdClientBuilderCapacitorConfig {
+    appId: string;
+    appName: string;
+    plugins?: Record<string, Record<string, unknown> | true>;
+    icon?: string;
+    debug?: boolean;
+    platform?: {
+        android?: {
+            config?: Record<string, string>;
+            bundle?: boolean;
+            sign?: {
+                keystore: string;
+                storePassword: string;
+                alias: string;
+                password: string;
+                keystoreType?: string;
+            };
+            sdkVersion?: number;
+            permissions?: {
+                name: string;
+                maxSdkVersion?: number;
+                ignore?: string;
+            }[];
+        };
+    };
+    env?: Record<string, string>;
+    browserslist?: string[];
+}
 export type TSdPostPublishConfig = ISdPostPublishScriptConfig;
 export interface ISdPostPublishScriptConfig {
     type: "script";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simplysm/sd-cli",
-  "version": "12.15.68",
+  "version": "12.15.69",
   "description": "심플리즘 패키지 - CLI",
   "author": "김석래",
   "repository": {
@@ -17,10 +17,10 @@
     "@angular/compiler-cli": "^20.3.15",
     "@anthropic-ai/sdk": "^0.71.2",
     "@electron/rebuild": "^4.0.2",
-    "@simplysm/sd-core-common": "12.15.68",
-    "@simplysm/sd-core-node": "12.15.68",
-    "@simplysm/sd-service-server": "12.15.68",
-    "@simplysm/sd-storage": "12.15.68",
+    "@simplysm/sd-core-common": "12.15.69",
+    "@simplysm/sd-core-node": "12.15.69",
+    "@simplysm/sd-service-server": "12.15.69",
+    "@simplysm/sd-storage": "12.15.69",
     "browserslist": "^4.28.1",
     "cordova": "^13.0.0",
     "electron": "^33.4.11",